struct_ops: use value type as MapSpec.Value and drop unused helpers (2)

Signed-off-by: shun159 <[email protected]>

Author: shun159

collection.go

@@ -675,7 +675,6 @@ func (cl *collectionLoader) loadVariable(varName string) (*Variable, error) {
 // populateDeferredMaps iterates maps holding programs or other maps and loads
 // any dependencies. Populates all maps in cl and freezes them if specified.
 func (cl *collectionLoader) populateDeferredMaps() error {
-	fmt.Println("hogehogehogehoge")
 	for mapName, m := range cl.maps {
 		mapSpec, ok := cl.coll.Maps[mapName]
 		if !ok {
@@ -721,7 +720,7 @@ func (cl *collectionLoader) populateDeferredMaps() error {
 		}
 
 		if mapSpec.Type == StructOpsMap {
-			vType, ok := btf.As[*btf.Struct](mapSpec.Value)
+			valueType, ok := btf.As[*btf.Struct](mapSpec.Value)
 			if !ok {
 				return fmt.Errorf("value should be a *Struct")
 			}
@@ -736,17 +735,17 @@ func (cl *collectionLoader) populateDeferredMaps() error {
 				return fmt.Errorf("load vmlinux BTF: %w", err)
 			}
 
-			kernType, _, _, err := findStructTypeByName(s, vType.Name)
+			vType, _, _, err := findStructTypeByName(s, valueType.Name)
 			if err != nil {
 				return fmt.Errorf("find value type: %w", err)
 			}
 
-			kernVData, err := translateStructData(vType, userData, kernType)
+			kernVData, err := translateStructData(valueType, userData, vType)
 			if err != nil {
 				return err
 			}
 
-			if err := populateFuncPtr(kernType, kernVData, cl.programs); err != nil {
+			if err := populateFuncPtr(vType, kernVData, cl.programs); err != nil {
 				return err
 			}
 
@@ -773,7 +772,6 @@ func translateStructData(from *btf.Struct, fromData []byte, to *btf.Struct) ([]b
 
 	for _, m := range to.Members {
 		st, ok := btf.As[*btf.Struct](btf.UnderlyingType(m.Type))
-		fmt.Println(m.Name, st.Name)
 		if ok && st.Name == innerName {
 			inner = st
 			innerOff = int(m.Offset / 8)
@@ -869,22 +867,21 @@ func (cl *collectionLoader) initKernStructOps() error {
 			continue
 		}
 
-		kernSt := ms.Value
-		if kernSt == nil {
+		valueSt := ms.Value
+		if valueSt == nil {
 			return fmt.Errorf("user struct type should be specified as Value")
 		}
 
-		kType, ok := btf.As[*btf.Struct](kernSt)
+		vType, ok := btf.As[*btf.Struct](valueSt)
 		if !ok {
 			return fmt.Errorf("user struct type should be a Struct")
 		}
 
 		// resolve kernel-side types (target + value type)
-		kernTypes, err := findStructOpsKernTypes(kType)
+		kernTypes, err := findStructOpsKernTypes(vType)
 		if err != nil {
 			return fmt.Errorf("find kern_type: %w", err)
 		}
-		ms.Value = kernTypes.typ
 
 		// allocate per-map state (names, offsets, kernel buffer, attach types, typeID)
 		structOps := &structOpsSpec{

collection_test.go

@@ -790,13 +790,13 @@ func TestStructOpsMapSpecSimpleLoadAndAssign(t *testing.T) {
 		},
 		Maps: map[string]*MapSpec{
 			"testmod_ops": {
-				Name:       "bpf_struct_ops_testmod_ops",
+				Name:       "testmod_ops",
 				Type:       StructOpsMap,
 				Flags:      sys.BPF_F_LINK,
 				KeySize:    4,
 				ValueSize:  448,
 				MaxEntries: 1,
-				Value:      &btf.Struct{Name: "bpf_testmod_ops"},
+				Value:      &btf.Struct{Name: "bpf_struct_ops_bpf_testmod_ops"},
 				Contents: []MapKV{
 					{
 						Key:   uint32(0),

map.go

@@ -569,19 +569,20 @@ func (spec *MapSpec) createMap(inner *sys.FD) (_ *Map, err error) {
 				return nil, fmt.Errorf("struct type is not specified as Value")
 			}
 
-			vType, ok := btf.As[*btf.Struct](spec.Value)
+			valueType, ok := btf.As[*btf.Struct](spec.Value)
 			if !ok {
 				return nil, fmt.Errorf("value must be Struct type")
 			}
 
 			// struct_ops: resolve value type ("bpf_struct_ops_<name>") and
 			// record kernel-specific BTF IDs / FDs needed for map creation.
-			kType, s, modBtfObjId, err := findStructTypeByName(s, vType.Name)
+			vType, s, modBtfObjId, err := findStructTypeByName(s, valueType.Name)
 			if err != nil {
-				return nil, fmt.Errorf("lookup struct type: %w", err)
+				return nil, fmt.Errorf("lookup value type %q: %w", valueType.Name, err)
 			}
 
-			btfValueTypeId, err := s.TypeID(kType)
+			btfValueTypeId, err := s.TypeID(vType)
+			fmt.Println(vType, btfValueTypeId)
 			if err != nil {
 				return nil, fmt.Errorf("lookup type_id: %w", err)
 			}

struct_ops.go

@@ -3,6 +3,7 @@ package ebpf
 import (
 	"errors"
 	"fmt"
+	"strings"
 
 	"github.com/cilium/ebpf/btf"
 	"github.com/cilium/ebpf/internal/sys"
@@ -19,8 +20,6 @@ type structOpsKernTypes struct {
 	typeID btf.TypeID
 	// value struct "bpf_struct_ops_<name>" that contains typ.
 	valueType *btf.Struct
-	// The *btf.Member within valueType that embeds typ.
-	dataMember *btf.Member
 	// The BTF object ID of the module where the type was found
 	// 0 if resolved in vmlinux.
 	modBtfObjId uint32
@@ -64,34 +63,6 @@ type structOpsSpec struct {
 	progAttachBtfID btf.TypeID
 }
 
-// findByTypeFromStruct searches for the first member of a struct whose
-// resolved BTF type ID matches the given typ.
-//
-// It resolves the BTF type ID of typ and compares it against each
-// member’s TypeID in st.Members. If a match is found, the corresponding
-// *btf.Member is returned.
-//
-// Returns an error if typ cannot be resolved, if any member type
-// resolution fails, or if no member with the requested type exists.
-func findByTypeFromStruct(spec *btf.Spec, st *btf.Struct, typ btf.Type) (*btf.Member, error) {
-	typeId, err := spec.TypeID(typ)
-	if err != nil {
-		return nil, fmt.Errorf("failed to resolve typeId for %s: %w", (typ).TypeName(), err)
-	}
-
-	for _, member := range st.Members {
-		memberTypeId, err := spec.TypeID(member.Type)
-		if err != nil {
-			return nil, fmt.Errorf("failed to resolve typeId for %s: %w", member.Name, err)
-		}
-		if memberTypeId == typeId {
-			return &member, nil
-		}
-	}
-
-	return nil, fmt.Errorf("member of type %s not found in %s", typ.TypeName(), st.Name)
-}
-
 // findStructTypeByName looks up a struct type with the exact name in the
 // provided base BTF spec, and falls back to scanning all loaded module BTFs
 // if it is not present in vmlinux.
@@ -168,32 +139,26 @@ func findStructTypeByNameFromModule(base *btf.Spec, name string) (*btf.Struct, *
 // findStructOpsKernTypes discovers all kernel-side BTF artifacts that belong to
 // a given struct_ops, identified by the user-visible base struct name
 // (e.g., "tcp_congestion_ops").
-func findStructOpsKernTypes(kType *btf.Struct) (*structOpsKernTypes, error) {
+func findStructOpsKernTypes(valueType *btf.Struct) (*structOpsKernTypes, error) {
 	spec, err := btf.LoadKernelSpec()
 	if err != nil {
 		return nil, fmt.Errorf("load vmlinux BTF: %w", err)
 	}
 
 	// 1. kernel target struct (e.g. tcp_congestion_ops)
-	kType, s, modID, err := findStructTypeByName(spec, kType.Name)
+	kTypeName := strings.TrimPrefix(valueType.Name, structOpsValuePrefix)
+	kType, s, modID, err := findStructTypeByName(spec, kTypeName)
 	if err != nil {
 		return nil, fmt.Errorf("struct type: %s %w", kType.TypeName(), err)
 	}
 
 	// 2. value struct (bpf_struct_ops_<name>)
-	vTypeName := structOpsValuePrefix + kType.Name
-	vType, _, _, err := findStructTypeByName(s, vTypeName)
+	vType, _, _, err := findStructTypeByName(s, valueType.Name)
 	if err != nil {
 		return nil, fmt.Errorf("kern struct type for %s %w", kType.TypeName(), err)
 	}
 
-	// 3. member “data” that embeds the real ops
-	dataMem, err := findByTypeFromStruct(s, vType, kType)
-	if err != nil {
-		return nil, err
-	}
-
-	// 4. type-ID of kernel target
+	// 3. type-ID of kernel target
 	kID, err := s.TypeID(kType)
 	if err != nil {
 		return nil, fmt.Errorf("type ID of %s: %w", kType.TypeName(), err)
@@ -204,7 +169,6 @@ func findStructOpsKernTypes(kType *btf.Struct) (*structOpsKernTypes, error) {
 		typ:         kType,
 		typeID:      kID,
 		valueType:   vType,
-		dataMember:  dataMem,
 		modBtfObjId: uint32(modID),
 	}, nil
 }

struct_ops_test.go

@@ -19,7 +19,7 @@ func TestCreateStructOpsMapSpecSimple(t *testing.T) {
 		KeySize:    4,
 		ValueSize:  448,
 		MaxEntries: 1,
-		Value:      &btf.Struct{Name: "bpf_struct_ops_testmod_ops"},
+		Value:      &btf.Struct{Name: "bpf_struct_ops_bpf_testmod_ops"},
 		Contents: []MapKV{
 			{
 				Key:   uint32(0),
@@ -33,7 +33,7 @@ func TestCreateStructOpsMapSpecSimple(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	_, _, _, err = findStructTypeByName(s, "bpf_struct_ops_testmod_ops")
+	_, _, _, err = findStructTypeByName(s, "bpf_struct_ops_bpf_testmod_ops")
 	if errors.Is(err, btf.ErrNotFound) {
 		t.Skip("bpf_testmod_ops not loaded")
 	}