btf: add essentialNameLen() to handle flavor underscores properly

Only treat triple underscores as a CO-RE flavor separator when surrounded
by non-underscore characters. This keeps names like ____fput distinct
while using the same normalization for lookup and decoder indexing.

Add tests for leading underscore runs and valid flavor suffixes.

See libbpf's bpf_core_essential_name_len().

Signed-off-by: Leon Hwang <leon.hwang@linux.dev>

Author: Asphaltt

btf/btf_test.go

@@ -134,17 +134,23 @@ func TestAnyTypesByNameNoExactMatch(t *testing.T) {
 }
 
 func TestAnyTypesByNameLeadingUnderscores(t *testing.T) {
-	// Kernel function names such as ___pskb_trim start with a triple
-	// underscore. This isn't a flavour delimiter, so the full name must
-	// remain queryable.
-	spec := specFromTypes(t, []Type{
-		&Int{Name: "___pskb_trim", Size: 4},
-	})
-
-	types, err := spec.AnyTypesByName("___pskb_trim")
-	qt.Assert(t, qt.IsNil(err))
-	qt.Assert(t, qt.HasLen(types, 1))
-	qt.Assert(t, qt.Equals(types[0].TypeName(), "___pskb_trim"))
+	// Leading sequences of underscores in kernel function names aren't flavour
+	// delimiters, so the full names must remain independently queryable.
+	names := []string{"___pskb_trim", "____fput", "____netdev_has_upper_dev"}
+	types := make([]Type, 0, len(names))
+	for _, name := range names {
+		types = append(types, &Int{Name: name, Size: 4})
+	}
+	spec := specFromTypes(t, types)
+
+	for _, name := range names {
+		t.Run(name, func(t *testing.T) {
+			types, err := spec.AnyTypesByName(string(newEssentialName(name)))
+			qt.Assert(t, qt.IsNil(err))
+			qt.Assert(t, qt.HasLen(types, 1))
+			qt.Assert(t, qt.Equals(types[0].TypeName(), name))
+		})
+	}
 }
 
 func TestAnyTypeByNameNoExactMatch(t *testing.T) {
@@ -564,7 +570,6 @@ func TestSpecConcurrentAccess(t *testing.T) {
 	var wg sync.WaitGroup
 	for range maxprocs {
 		wg.Go(func() {
-
 			n := cond.Add(1)
 			for cond.Load() != int64(maxprocs) {
 				// Spin to increase the chances of a race.

btf/types.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"io"
 	"math"
-	"strings"
 
 	"github.com/cilium/ebpf/asm"
 	"github.com/cilium/ebpf/internal"
@@ -800,21 +799,30 @@ type typeDeque = internal.Deque[*Type]
 // suffixes after a ___ delimiter.
 type essentialName string
 
-// newEssentialName returns name without a ___ suffix.
+// essentialNameLen returns the length of name without a ___ suffix.
 //
 // CO-RE has the concept of 'struct flavors', which are used to deal with
-// changes in kernel data structures. Anything after three underscores
-// in a type name is ignored for the purpose of finding a candidate type
+// changes in kernel data structures. A flavour separator is a sequence of
+// three underscores surrounded by non-underscore characters. Anything after
+// the last separator is ignored for the purpose of finding a candidate type
 // in the kernel's BTF.
-func newEssentialName(name string) essentialName {
-	if name == "" {
-		return ""
-	}
-	lastIdx := strings.LastIndex(name, "___")
-	if lastIdx > 0 {
-		return essentialName(name[:lastIdx])
+//
+// See libbpf bpf_core_essential_name_len() implementation.
+func essentialNameLen[T ~string | ~[]byte](name T) int {
+	for i := len(name) - 5; i >= 0; i-- {
+		if name[i] != '_' &&
+			name[i+1] == '_' && name[i+2] == '_' && name[i+3] == '_' &&
+			name[i+4] != '_' {
+			return i + 1
+		}
 	}
-	return essentialName(name)
+
+	return len(name)
+}
+
+// newEssentialName returns name without a ___ suffix.
+func newEssentialName(name string) essentialName {
+	return essentialName(name[:essentialNameLen(name)])
 }
 
 // UnderlyingType skips qualifiers and Typedefs.

btf/types_test.go

@@ -12,6 +12,26 @@ import (
 	"github.com/cilium/ebpf/internal/testutils"
 )
 
+func TestEssentialName(t *testing.T) {
+	tests := map[string]string{
+		"":                         "",
+		"foo":                      "foo",
+		"foo___flavour":            "foo",
+		"foo___one___two":          "foo___one",
+		"___pskb_trim":             "___pskb_trim",
+		"____fput":                 "____fput",
+		"____netdev_has_upper_dev": "____netdev_has_upper_dev",
+		"foo____flavour":           "foo____flavour",
+		"foo___":                   "foo___",
+	}
+
+	for name, want := range tests {
+		t.Run(name, func(t *testing.T) {
+			qt.Assert(t, qt.Equals(string(newEssentialName(name)), want))
+		})
+	}
+}
+
 func TestSizeof(t *testing.T) {
 	testcases := []struct {
 		size int

btf/unmarshal.go

@@ -1,7 +1,6 @@
 package btf
 
 import (
-	"bytes"
 	"encoding/binary"
 	"fmt"
 	"hash/maphash"
@@ -118,17 +117,7 @@ func newDecoder(raw []byte, bo binary.ByteOrder, strings *stringTable, base *dec
 		}
 
 		if len(name) > 0 {
-			if i := bytes.Index(name, []byte("___")); i != -1 {
-				// Flavours are rare. It's cheaper to find the first index for some
-				// reason.
-				//
-				// A leading "___" isn't a flavour delimiter (matches
-				// newEssentialName), so only strip if it doesn't start the name.
-				if i = bytes.LastIndex(name, []byte("___")); i > 0 {
-					name = name[:i]
-				}
-			}
-
+			name = name[:essentialNameLen(name)]
 			namedTypes.Add(name, id)
 		}