map: build BTF on the fly

Use btf.Encoder to write out MapSpec.Key and MapSpec.Value if necessary.
MapSpec.BTF is now unused, and therefore deprecated like ProgramSpec.BTF.

Author: lmb

btf/marshal.go

@@ -348,3 +348,32 @@ func (e *encoder) deflateVarSecinfos(vars []VarSecinfo) []btfVarSecinfo {
 	}
 	return vsis
 }
+
+// MarshalMapKV creates a BTF object containing a map key and value.
+//
+// The function is intended for the use of the ebpf package and may be removed
+// at any point in time.
+func MarshalMapKV(key, value Type) (_ *Handle, keyID, valueID TypeID, _ error) {
+	enc := nativeEncoderPool.Get().(*encoder)
+	defer nativeEncoderPool.Put(enc)
+
+	enc.Reset()
+
+	keyID, err := enc.Add(key)
+	if err != nil {
+		return nil, 0, 0, err
+	}
+
+	valueID, err = enc.Add(value)
+	if err != nil {
+		return nil, 0, 0, err
+	}
+
+	btf, err := enc.Encode()
+	if err != nil {
+		return nil, 0, 0, fmt.Errorf("marshal BTF: %w", err)
+	}
+
+	handle, err := newHandleFromRawBTF(btf)
+	return handle, keyID, valueID, err
+}

collection.go

@@ -386,42 +386,11 @@ func NewCollectionWithOptions(spec *CollectionSpec, opts CollectionOptions) (*Co
 	}, nil
 }
 
-type handleCache struct {
-	btfHandles map[*btf.Spec]*btf.Handle
-}
-
-func newHandleCache() *handleCache {
-	return &handleCache{
-		btfHandles: make(map[*btf.Spec]*btf.Handle),
-	}
-}
-
-func (hc handleCache) btfHandle(spec *btf.Spec) (*btf.Handle, error) {
-	if hc.btfHandles[spec] != nil {
-		return hc.btfHandles[spec], nil
-	}
-
-	handle, err := btf.NewHandle(spec)
-	if err != nil {
-		return nil, err
-	}
-
-	hc.btfHandles[spec] = handle
-	return handle, nil
-}
-
-func (hc handleCache) close() {
-	for _, handle := range hc.btfHandles {
-		handle.Close()
-	}
-}
-
 type collectionLoader struct {
 	coll     *CollectionSpec
 	opts     *CollectionOptions
 	maps     map[string]*Map
 	programs map[string]*Program
-	handles  *handleCache
 }
 
 func newCollectionLoader(coll *CollectionSpec, opts *CollectionOptions) (*collectionLoader, error) {
@@ -446,13 +415,11 @@ func newCollectionLoader(coll *CollectionSpec, opts *CollectionOptions) (*collec
 		opts,
 		make(map[string]*Map),
 		make(map[string]*Program),
-		newHandleCache(),
 	}, nil
 }
 
 // close all resources left over in the collectionLoader.
 func (cl *collectionLoader) close() {
-	cl.handles.close()
 	for _, m := range cl.maps {
 		m.Close()
 	}
@@ -486,7 +453,7 @@ func (cl *collectionLoader) loadMap(mapName string) (*Map, error) {
 		return m, nil
 	}
 
-	m, err := newMapWithOptions(mapSpec, cl.opts.Maps, cl.handles)
+	m, err := newMapWithOptions(mapSpec, cl.opts.Maps)
 	if err != nil {
 		return nil, fmt.Errorf("map %s: %w", mapName, err)
 	}

elf_reader.go

@@ -897,13 +897,6 @@ func mapSpecFromBTF(es *elfSection, vs *btf.VarSecinfo, def *btf.Struct, spec *b
 		}
 	}
 
-	if key == nil {
-		key = &btf.Void{}
-	}
-	if value == nil {
-		value = &btf.Void{}
-	}
-
 	return &MapSpec{
 		Name:       SanitizeName(name, -1),
 		Type:       MapType(mapType),

elf_reader_test.go

@@ -361,6 +361,19 @@ func TestLoadInitializedBTFMap(t *testing.T) {
 			t.Fatal(err)
 		}
 
+		t.Run("NewCollection", func(t *testing.T) {
+			if coll.ByteOrder != internal.NativeEndian {
+				t.Skipf("Skipping %s collection", coll.ByteOrder)
+			}
+
+			tmp, err := NewCollection(coll)
+			testutils.SkipIfNotSupported(t, err)
+			if err != nil {
+				t.Fatal("NewCollection failed:", err)
+			}
+			tmp.Close()
+		})
+
 		t.Run("prog_array", func(t *testing.T) {
 			m, ok := coll.Maps["prog_array_init"]
 			if !ok {
@@ -395,6 +408,22 @@ func TestLoadInitializedBTFMap(t *testing.T) {
 				t.Error("expecting exactly 1 item in MapSpec contents")
 			}
 
+			if m.Key == nil {
+				t.Error("Expected non-nil key")
+			}
+
+			if m.Value == nil {
+				t.Error("Expected non-nil value")
+			}
+
+			if m.InnerMap.Key == nil {
+				t.Error("Expected non-nil InnerMap key")
+			}
+
+			if m.InnerMap.Value == nil {
+				t.Error("Expected non-nil InnerMap value")
+			}
+
 			p := m.Contents[0]
 			if cmp.Equal(p.Key, 1) {
 				t.Errorf("expecting MapSpec entry Key to equal 1, got %v", p.Key)

map.go

@@ -79,6 +79,8 @@ type MapSpec struct {
 	Key, Value btf.Type
 
 	// The BTF associated with this map.
+	//
+	// Deprecated: use [CollectionSpec.Types] instead.
 	BTF *btf.Spec
 }
 
@@ -104,12 +106,6 @@ func (ms *MapSpec) Copy() *MapSpec {
 	return &cpy
 }
 
-// hasBTF returns true if the MapSpec has a valid BTF spec and if its
-// map type supports associated BTF metadata in the kernel.
-func (ms *MapSpec) hasBTF() bool {
-	return ms.BTF != nil && ms.Type.hasBTF()
-}
-
 func (ms *MapSpec) clampPerfEventArraySize() error {
 	if ms.Type != PerfEventArray {
 		return nil
@@ -241,10 +237,7 @@ func NewMap(spec *MapSpec) (*Map, error) {
 //
 // May return an error wrapping ErrMapIncompatible.
 func NewMapWithOptions(spec *MapSpec, opts MapOptions) (*Map, error) {
-	handles := newHandleCache()
-	defer handles.close()
-
-	m, err := newMapWithOptions(spec, opts, handles)
+	m, err := newMapWithOptions(spec, opts)
 	if err != nil {
 		return nil, fmt.Errorf("creating map: %w", err)
 	}
@@ -257,7 +250,7 @@ func NewMapWithOptions(spec *MapSpec, opts MapOptions) (*Map, error) {
 	return m, nil
 }
 
-func newMapWithOptions(spec *MapSpec, opts MapOptions, handles *handleCache) (_ *Map, err error) {
+func newMapWithOptions(spec *MapSpec, opts MapOptions) (_ *Map, err error) {
 	closeOnError := func(c io.Closer) {
 		if err != nil {
 			c.Close()
@@ -307,7 +300,7 @@ func newMapWithOptions(spec *MapSpec, opts MapOptions, handles *handleCache) (_
 			return nil, errors.New("inner maps cannot be pinned")
 		}
 
-		template, err := spec.InnerMap.createMap(nil, opts, handles)
+		template, err := spec.InnerMap.createMap(nil, opts)
 		if err != nil {
 			return nil, fmt.Errorf("inner map: %w", err)
 		}
@@ -319,7 +312,7 @@ func newMapWithOptions(spec *MapSpec, opts MapOptions, handles *handleCache) (_
 		innerFd = template.fd
 	}
 
-	m, err := spec.createMap(innerFd, opts, handles)
+	m, err := spec.createMap(innerFd, opts)
 	if err != nil {
 		return nil, err
 	}
@@ -337,7 +330,7 @@ func newMapWithOptions(spec *MapSpec, opts MapOptions, handles *handleCache) (_
 
 // createMap validates the spec's properties and creates the map in the kernel
 // using the given opts. It does not populate or freeze the map.
-func (spec *MapSpec) createMap(inner *sys.FD, opts MapOptions, handles *handleCache) (_ *Map, err error) {
+func (spec *MapSpec) createMap(inner *sys.FD, opts MapOptions) (_ *Map, err error) {
 	closeOnError := func(closer io.Closer) {
 		if err != nil {
 			closer.Close()
@@ -425,22 +418,15 @@ func (spec *MapSpec) createMap(inner *sys.FD, opts MapOptions, handles *handleCa
 		attr.MapName = sys.NewObjName(spec.Name)
 	}
 
-	if spec.hasBTF() {
-		handle, err := handles.btfHandle(spec.BTF)
-		if err != nil && !errors.Is(err, btf.ErrNotSupported) {
+	btfDisabled := false
+	if spec.Type.supportsBTF() && (spec.Key != nil || spec.Value != nil) {
+		handle, keyTypeID, valueTypeID, err := btf.MarshalMapKV(spec.Key, spec.Value)
+		btfDisabled = errors.Is(err, btf.ErrNotSupported)
+		if err != nil && !btfDisabled {
 			return nil, fmt.Errorf("load BTF: %w", err)
 		}
-
 		if handle != nil {
-			keyTypeID, err := spec.BTF.TypeID(spec.Key)
-			if err != nil {
-				return nil, err
-			}
-
-			valueTypeID, err := spec.BTF.TypeID(spec.Value)
-			if err != nil {
-				return nil, err
-			}
+			defer handle.Close()
 
 			attr.BtfFd = uint32(handle.FD())
 			attr.BtfKeyTypeId = uint32(keyTypeID)
@@ -453,12 +439,12 @@ func (spec *MapSpec) createMap(inner *sys.FD, opts MapOptions, handles *handleCa
 		if errors.Is(err, unix.EPERM) {
 			return nil, fmt.Errorf("map create: %w (MEMLOCK may be too low, consider rlimit.RemoveMemlock)", err)
 		}
-		if !spec.hasBTF() {
-			return nil, fmt.Errorf("map create without BTF: %w", err)
-		}
 		if errors.Is(err, unix.EINVAL) && attr.MaxEntries == 0 {
 			return nil, fmt.Errorf("map create: %w (MaxEntries may be incorrectly set to zero)", err)
 		}
+		if btfDisabled {
+			return nil, fmt.Errorf("map create: %w (kernel without BTF support)", err)
+		}
 		return nil, fmt.Errorf("map create: %w", err)
 	}
 	defer closeOnError(fd)

map_test.go

@@ -12,7 +12,6 @@ import (
 	"unsafe"
 
 	"github.com/cilium/ebpf/asm"
-	"github.com/cilium/ebpf/btf"
 	"github.com/cilium/ebpf/internal"
 	"github.com/cilium/ebpf/internal/sys"
 	"github.com/cilium/ebpf/internal/testutils"
@@ -1655,22 +1654,28 @@ func TestMapPinning(t *testing.T) {
 	pinned := m1.IsPinned()
 	c.Assert(pinned, qt.IsTrue)
 
+	m1Info, err := m1.Info()
+	c.Assert(err, qt.IsNil)
+
 	if err := m1.Put(uint32(0), uint32(42)); err != nil {
 		t.Fatal("Can't write value:", err)
 	}
 
-	// This is a terrible hack: if loading a pinned map tries to load BTF,
-	// it will get a nil *btf.Spec from this *btf.Map. This is turn will make
-	// btf.NewHandle fail.
-	spec.BTF = new(btf.Spec)
-
 	m2, err := NewMapWithOptions(spec, MapOptions{PinPath: tmp})
 	testutils.SkipIfNotSupported(t, err)
 	if err != nil {
 		t.Fatal("Can't create map:", err)
 	}
 	defer m2.Close()
 
+	m2Info, err := m2.Info()
+	c.Assert(err, qt.IsNil)
+
+	if m1ID, ok := m1Info.ID(); ok {
+		m2ID, _ := m2Info.ID()
+		c.Assert(m2ID, qt.Equals, m1ID)
+	}
+
 	var value uint32
 	if err := m2.Lookup(uint32(0), &value); err != nil {
 		t.Fatal("Can't read from map:", err)

testdata/btf_map_init-eb.elf

@@ -43,8 +43,8 @@ struct {
 struct {
 	__uint(type, BPF_MAP_TYPE_ARRAY_OF_MAPS);
 	__uint(max_entries, 2);
-	__uint(key_size, sizeof(uint32_t));
-	__uint(value_size, sizeof(uint32_t));
+	__type(key, uint32_t);
+	__type(value, uint32_t);
 	__array(values, typeof(inner_map));
 } outer_map_init __section(".maps") = {
 	.values =

testdata/btf_map_init-el.elf

@@ -121,8 +121,8 @@ func (mt MapType) canStoreProgram() bool {
 	return mt == ProgramArray
 }
 
-// hasBTF returns true if the map type supports BTF key/value metadata.
-func (mt MapType) hasBTF() bool {
+// supportsBTF returns true if the map type supports BTF key/value metadata.
+func (mt MapType) supportsBTF() bool {
 	switch mt {
 	case PerfEventArray, CGroupArray, StackTrace, ArrayOfMaps, HashOfMaps, DevMap,
 		DevMapHash, CPUMap, XSKMap, SockMap, SockHash, Queue, Stack, RingBuf: