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

Set MapSpec.Value to the "value struct" (`bpf_struct_ops_<ops>`) instead of the "kern struct".
This matches the actual BTF layout where the sturct_ops struct matches with the `data` member inside the value type.

Also remove unused helper functions (`findStructByNameWithPrefix`, `doFindStructTypeByName`, etc.)
to simplify type resolution.

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

Author: shun159

collection.go

@@ -721,7 +721,7 @@ func (cl *collectionLoader) populateDeferredMaps() error {
 		}
 
 		if mapSpec.Type == StructOpsMap {
-			userType, ok := btf.As[*btf.Struct](mapSpec.Value)
+			vType, ok := btf.As[*btf.Struct](mapSpec.Value)
 			if !ok {
 				return fmt.Errorf("value should be a *Struct")
 			}
@@ -736,12 +736,12 @@ func (cl *collectionLoader) populateDeferredMaps() error {
 				return fmt.Errorf("load vmlinux BTF: %w", err)
 			}
 
-			kernType, _, _, err := findStructByNameWithPrefix(s, userType)
+			kernType, _, _, err := findStructTypeByName(s, vType.Name)
 			if err != nil {
-				return fmt.Errorf("find wrapper type: %w", err)
+				return fmt.Errorf("find value type: %w", err)
 			}
 
-			kernVData, err := translateStructData(userType, userData, kernType)
+			kernVData, err := translateStructData(vType, userData, kernType)
 			if err != nil {
 				return err
 			}
@@ -826,13 +826,13 @@ func translateStructData(from *btf.Struct, fromData []byte, to *btf.Struct) ([]b
 }
 
 // populateFuncPtr writes progFD into `data` at the offset
-func populateFuncPtr(wrapper *btf.Struct, data []byte, programs map[string]*Program) error {
-	innerName := strings.TrimPrefix(wrapper.Name, structOpsValuePrefix)
+func populateFuncPtr(vType *btf.Struct, data []byte, programs map[string]*Program) error {
+	innerName := strings.TrimPrefix(vType.Name, structOpsValuePrefix)
 
 	var inner *btf.Struct
 	var innerOff int
 
-	for _, m := range wrapper.Members {
+	for _, m := range vType.Members {
 		st, ok := btf.As[*btf.Struct](btf.UnderlyingType(m.Type))
 		if ok && st.Name == innerName {
 			inner = st
@@ -841,7 +841,7 @@ func populateFuncPtr(wrapper *btf.Struct, data []byte, programs map[string]*Prog
 	}
 
 	if inner == nil {
-		return fmt.Errorf("member %s not found in %s", innerName, wrapper.Name)
+		return fmt.Errorf("member %s not found in %s", innerName, vType.Name)
 	}
 
 	for _, m := range inner.Members {
@@ -869,18 +869,18 @@ func (cl *collectionLoader) initKernStructOps() error {
 			continue
 		}
 
-		userSt := ms.Value
-		if userSt == nil {
+		kernSt := ms.Value
+		if kernSt == nil {
 			return fmt.Errorf("user struct type should be specified as Value")
 		}
 
-		userStructType, ok := btf.As[*btf.Struct](ms.Value)
+		kType, ok := btf.As[*btf.Struct](kernSt)
 		if !ok {
 			return fmt.Errorf("user struct type should be a Struct")
 		}
 
-		// resolve kernel-side types (target + wrapper)
-		kernTypes, err := findStructOpsKernTypes(userStructType)
+		// resolve kernel-side types (target + value type)
+		kernTypes, err := findStructOpsKernTypes(kType)
 		if err != nil {
 			return fmt.Errorf("find kern_type: %w", err)
 		}

collection_test.go

@@ -790,7 +790,7 @@ func TestStructOpsMapSpecSimpleLoadAndAssign(t *testing.T) {
 		},
 		Maps: map[string]*MapSpec{
 			"testmod_ops": {
-				Name:       "testmod_ops",
+				Name:       "bpf_struct_ops_testmod_ops",
 				Type:       StructOpsMap,
 				Flags:      sys.BPF_F_LINK,
 				KeySize:    4,
@@ -812,7 +812,7 @@ func TestStructOpsMapSpecSimpleLoadAndAssign(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	_, _, _, err = doFindStructTypeByName(s, "bpf_testmod_ops")
+	_, _, _, err = findStructTypeByName(s, "bpf_testmod_ops")
 	if errors.Is(err, btf.ErrNotFound) {
 		t.Skip("bpf_testmod_ops not loaded")
 	}

map.go

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

prog.go

@@ -408,7 +408,7 @@ func newProgramWithOptions(spec *ProgramSpec, opts ProgramOptions, c *btf.Cache)
 				return nil, fmt.Errorf("load vmlinux BTF: %w", err)
 			}
 
-			st, spec2, modBtfObjID, err := doFindStructTypeByName(s, attachTo)
+			st, spec2, modBtfObjID, err := findStructTypeByName(s, attachTo)
 			if err != nil {
 				return nil, err
 			}
@@ -436,7 +436,7 @@ func newProgramWithOptions(spec *ProgramSpec, opts ProgramOptions, c *btf.Cache)
 			}
 		}
 
-		if module != nil {
+		if module != nil && attr.AttachBtfObjFd == 0 {
 			attr.AttachBtfObjFd = uint32(module.FD())
 			defer module.Close()
 		}

struct_ops.go

@@ -17,7 +17,7 @@ type structOpsKernTypes struct {
 	// target kernel struct type (e.g. tcp_congestion_ops).
 	typ    *btf.Struct
 	typeID btf.TypeID
-	// wrapper struct "bpf_struct_ops_<name>" that contains typ.
+	// value struct "bpf_struct_ops_<name>" that contains typ.
 	valueType *btf.Struct
 	// The *btf.Member within valueType that embeds typ.
 	dataMember *btf.Member
@@ -92,33 +92,7 @@ func findByTypeFromStruct(spec *btf.Spec, st *btf.Struct, typ btf.Type) (*btf.Me
 	return nil, fmt.Errorf("member of type %s not found in %s", typ.TypeName(), st.Name)
 }
 
-// findStructByNameWithPrefix resolves a struct_ops "value" type by name,
-// after applying the standard prefix convention.
-//
-// It expects val to be the user-visible struct type (e.g. "bpf_dummy_ops")
-// and looks up the kernel-side wrapper name:
-//
-//	"bpf_dummy_ops" -> "bpf_struct_ops_bpf_dummy_ops"
-//
-// Returns the matching *btf.Struct, the *btf.Spec it was found in (either the
-// base vmlinux spec or a module spec), and the module BTF ID (0 for vmlinux).
-// See doFindStructTypeByName for resolution details and error behavior.
-func findStructByNameWithPrefix(s *btf.Spec, val *btf.Struct) (*btf.Struct, *btf.Spec, uint32, error) {
-	return doFindStructTypeByName(s, structOpsValuePrefix+val.TypeName())
-}
-
-// findStructTypeByName resolves the exact BTF struct type that corresponds
-// to typ.TypeName() by searching first in vmlinux and then across all loaded
-// kernel modules.
-//
-// Returns the first *btf.Struct that matches the name verbatim, the *btf.Spec
-// where it was found, and the module BTF ID (0 if found in vmlinux).
-// If no matching struct exists anywhere, btf.ErrNotFound is returned.
-func findStructTypeByName(s *btf.Spec, typ *btf.Struct) (*btf.Struct, *btf.Spec, uint32, error) {
-	return doFindStructTypeByName(s, typ.TypeName())
-}
-
-// doFindStructTypeByName looks up a struct type with the exact name in the
+// 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.
 //
@@ -131,7 +105,7 @@ func findStructTypeByName(s *btf.Spec, typ *btf.Struct) (*btf.Struct, *btf.Spec,
 //
 // Returns (*btf.Struct, *btf.Spec, moduleID, nil) on success, or btf.ErrNotFound
 // if no matching struct is present in vmlinux or any module.
-func doFindStructTypeByName(s *btf.Spec, name string) (*btf.Struct, *btf.Spec, uint32, error) {
+func findStructTypeByName(s *btf.Spec, name string) (*btf.Struct, *btf.Spec, uint32, error) {
 	if s == nil {
 		return nil, nil, 0, fmt.Errorf("nil BTF: %w", btf.ErrNotFound)
 	}
@@ -194,26 +168,27 @@ 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(userStructType *btf.Struct) (*structOpsKernTypes, error) {
+func findStructOpsKernTypes(kType *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, userStructType)
+	kType, s, modID, err := findStructTypeByName(spec, kType.Name)
 	if err != nil {
-		return nil, fmt.Errorf("struct type: %s %w", userStructType.TypeName(), err)
+		return nil, fmt.Errorf("struct type: %s %w", kType.TypeName(), err)
 	}
 
-	// 2. wrapper struct (bpf_struct_ops_<name>)
-	wType, _, _, err := findStructByNameWithPrefix(s, userStructType)
+	// 2. value struct (bpf_struct_ops_<name>)
+	vTypeName := structOpsValuePrefix + kType.Name
+	vType, _, _, err := findStructTypeByName(s, vTypeName)
 	if err != nil {
-		return nil, fmt.Errorf("kern struct type for %s %w", userStructType.TypeName(), err)
+		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, wType, kType)
+	dataMem, err := findByTypeFromStruct(s, vType, kType)
 	if err != nil {
 		return nil, err
 	}
@@ -228,7 +203,7 @@ func findStructOpsKernTypes(userStructType *btf.Struct) (*structOpsKernTypes, er
 		spec:        s,
 		typ:         kType,
 		typeID:      kID,
-		valueType:   wType,
+		valueType:   vType,
 		dataMember:  dataMem,
 		modBtfObjId: uint32(modID),
 	}, nil

struct_ops_test.go

@@ -19,8 +19,7 @@ func TestCreateStructOpsMapSpecSimple(t *testing.T) {
 		KeySize:    4,
 		ValueSize:  448,
 		MaxEntries: 1,
-		// we use `Value` to specify a user struct type as BTF
-		Value: &btf.Struct{Name: "bpf_testmod_ops"},
+		Value:      &btf.Struct{Name: "bpf_struct_ops_testmod_ops"},
 		Contents: []MapKV{
 			{
 				Key:   uint32(0),
@@ -34,7 +33,7 @@ func TestCreateStructOpsMapSpecSimple(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	_, _, _, err = doFindStructTypeByName(s, "bpf_testmod_ops")
+	_, _, _, err = findStructTypeByName(s, "bpf_struct_ops_testmod_ops")
 	if errors.Is(err, btf.ErrNotFound) {
 		t.Skip("bpf_testmod_ops not loaded")
 	}