btf: add a workaround for the "No type found" error

The kernel accepts line info for each instruction in a program,
which is output as part of the verifier log and therefore provides
very important context. The strings for each line info are interned
into a BTF blob.

Unfortunately, the kernel refuses to load BTF with a string table but
without any types. This means it's not possible to add line info to
a program which doesn't use BTF otherwise.

Add a MarshalOption which fixes this behaviour by adding a dummy type
if necessary.

Signed-off-by: Lorenz Bauer <[email protected]>

Author: lmb

btf/btf_test.go

@@ -308,7 +308,9 @@ func TestLoadSpecFromElf(t *testing.T) {
 }
 
 func TestVerifierError(t *testing.T) {
-	_, err := NewHandle(&Builder{})
+	b, err := NewBuilder([]Type{&Int{Encoding: 255}})
+	qt.Assert(t, qt.IsNil(err))
+	_, err = NewHandle(b)
 	testutils.SkipIfNotSupported(t, err)
 	var ve *internal.VerifierError
 	if !errors.As(err, &ve) {

btf/marshal.go

@@ -20,14 +20,17 @@ type MarshalOptions struct {
 	StripFuncLinkage bool
 	// Replace Enum64 with a placeholder for compatibility with <6.0 kernels.
 	ReplaceEnum64 bool
+	// Prevent the "No type found" error when loading BTF without any types.
+	PreventNoTypeFound bool
 }
 
 // KernelMarshalOptions will generate BTF suitable for the current kernel.
 func KernelMarshalOptions() *MarshalOptions {
 	return &MarshalOptions{
-		Order:            internal.NativeEndian,
-		StripFuncLinkage: haveFuncLinkage() != nil,
-		ReplaceEnum64:    haveEnum64() != nil,
+		Order:              internal.NativeEndian,
+		StripFuncLinkage:   haveFuncLinkage() != nil,
+		ReplaceEnum64:      haveEnum64() != nil,
+		PreventNoTypeFound: true, // All current kernels require this.
 	}
 }
 
@@ -94,9 +97,9 @@ func NewBuilder(types []Type) (*Builder, error) {
 	return b, nil
 }
 
-// Empty returns true if [Add] has not been invoked on the builder.
+// Empty returns true if neither types nor strings have been added.
 func (b *Builder) Empty() bool {
-	return len(b.types) == 0
+	return len(b.types) == 0 && (b.strings == nil || b.strings.Length() == 0)
 }
 
 // Add a Type and allocate a stable ID for it.
@@ -169,10 +172,24 @@ func (b *Builder) Marshal(buf []byte, opts *MarshalOptions) ([]byte, error) {
 		ids:            maps.Clone(b.stableIDs),
 	}
 
+	if e.ids == nil {
+		e.ids = make(map[Type]TypeID)
+	}
+
+	types := b.types
+	if len(types) == 0 && stb.Length() > 0 && opts.PreventNoTypeFound {
+		// We have strings that need to be written out,
+		// but no types (besides the implicit Void).
+		// Kernels as recent as v6.7 refuse to load such BTF
+		// with a "No type found" error in the log.
+		// Fix this by adding a dummy type.
+		types = []Type{&Int{Size: 0}}
+	}
+
 	// Ensure that types are marshaled in the exact order they were Add()ed.
 	// Otherwise the ID returned from Add() won't match.
-	e.pending.Grow(len(b.types))
-	for _, typ := range b.types {
+	e.pending.Grow(len(types))
+	for _, typ := range types {
 		e.pending.Push(typ)
 	}
 

btf/workarounds_test.go

@@ -7,6 +7,8 @@ import (
 
 	"github.com/cilium/ebpf/internal"
 	"github.com/cilium/ebpf/internal/testutils"
+
+	"github.com/go-quicktest/qt"
 )
 
 func TestDatasecResolveWorkaround(t *testing.T) {
@@ -64,3 +66,15 @@ func TestDatasecResolveWorkaround(t *testing.T) {
 		})
 	}
 }
+
+func TestEmptyBTFWithStringTableWorkaround(t *testing.T) {
+	var b Builder
+
+	_, err := b.addString("foo")
+	qt.Assert(t, qt.IsNil(err))
+
+	h, err := NewHandle(&b)
+	testutils.SkipIfNotSupported(t, err)
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.IsNil(h.Close()))
+}