struct_ops: remove necessary function and struct type

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

Author: shun159

collection.go

@@ -418,8 +418,6 @@ type collectionLoader struct {
 	programs map[string]*Program
 	vars     map[string]*Variable
 	types    *btf.Cache
-	// map name -> structOpsSpec
-	stOpsSpecs map[string]*structOpsSpec
 	// structOps program name -> structOpsMap name
 	stOpsProgsToMap map[string]string
 }
@@ -447,7 +445,6 @@ func newCollectionLoader(coll *CollectionSpec, opts *CollectionOptions) (*collec
 		make(map[string]*Program),
 		make(map[string]*Variable),
 		newBTFCache(&opts.Programs),
-		make(map[string]*structOpsSpec),
 		make(map[string]string),
 	}, nil
 }
@@ -593,25 +590,6 @@ func (cl *collectionLoader) loadProgram(progName string) (*Program, error) {
 
 	cl.programs[progName] = prog
 
-	if prog.Type() == StructOps {
-		mapName, ok := cl.stOpsProgsToMap[prog.name]
-		if !ok {
-			return nil, fmt.Errorf("program %s should be linked to a StructOpsMap", prog.name)
-		}
-
-		structOps, ok := cl.stOpsSpecs[mapName]
-		if !ok {
-			return nil, fmt.Errorf("program %s has been loaded but not associated", prog.name)
-		}
-
-		attachType := structOps.progAttachType[prog.name]
-		if int(attachType) > len(structOps.kernTypes.typ.Members) {
-			return nil, fmt.Errorf("program %s: unexpected attach type %d",
-				prog.name, attachType)
-		}
-		structOps.programName[attachType] = progSpec.Name
-	}
-
 	return prog, nil
 }
 
@@ -862,6 +840,11 @@ func populateFuncPtr(vType *btf.Struct, data []byte, programs map[string]*Progra
 // initKernStructOps indexes struct_ops maps: resolve kernel types, allocate per-map state,
 // and stage copy/attach metadata. No kernel objects are created here.
 func (cl *collectionLoader) initKernStructOps() error {
+	s, err := btf.LoadKernelSpec()
+	if err != nil {
+		return fmt.Errorf("load vmlinux BTF: %w", err)
+	}
+
 	for _, ms := range cl.coll.Maps {
 		if ms.Type != StructOpsMap {
 			continue
@@ -877,24 +860,13 @@ func (cl *collectionLoader) initKernStructOps() error {
 			return fmt.Errorf("user struct type should be a Struct")
 		}
 
-		// resolve kernel-side types (target + value type)
-		kernTypes, err := findStructOpsKernTypes(vType)
+		kTypeName := strings.TrimPrefix(vType.Name, structOpsValuePrefix)
+		kType, _, _, err := findStructTypeByName(s, kTypeName)
 		if err != nil {
-			return fmt.Errorf("find kern_type: %w", err)
-		}
-
-		// allocate per-map state (names, offsets, kernel buffer, attach types, typeID)
-		structOps := &structOpsSpec{
-			make([]string, len(kernTypes.typ.Members)),
-			make([]int, len(kernTypes.typ.Members)),
-			make([]byte, kernTypes.valueType.Size),
-			kernTypes,
-			make(map[string]sys.AttachType),
-			kernTypes.typeID,
+			return fmt.Errorf("struct type: %s %w", kTypeName, err)
 		}
 
-		cl.stOpsSpecs[ms.Name] = structOps
-		cl.setStructOpsProgAttachTo(kernTypes.typ, ms.Name)
+		cl.setStructOpsProgAttachTo(kType, ms.Name)
 	}
 
 	return nil

struct_ops.go

@@ -3,66 +3,12 @@ package ebpf
 import (
 	"errors"
 	"fmt"
-	"strings"
 
 	"github.com/cilium/ebpf/btf"
-	"github.com/cilium/ebpf/internal/sys"
 )
 
 const structOpsValuePrefix = "bpf_struct_ops_"
 
-// structOpsKernTypes groups all kernel-side BTF artefacts that belong to a
-// resolved struct_ops.
-type structOpsKernTypes struct {
-	spec *btf.Spec
-	// target kernel struct type (e.g. tcp_congestion_ops).
-	typ    *btf.Struct
-	typeID btf.TypeID
-	// value struct "bpf_struct_ops_<name>" that contains typ.
-	valueType *btf.Struct
-	// The BTF object ID of the module where the type was found
-	// 0 if resolved in vmlinux.
-	modBtfObjId uint32
-}
-
-// used to holds "environment specific" data
-type structOpsSpec struct {
-	// programName keeps track of program symbols by attach order.
-	programName []string
-
-	// kernFuncOff contains the byte offsets into kernVData where
-	// program FDs must be written for function pointer members.
-	kernFuncOff []int
-
-	/*
-	 * kernVData mirrors the kernel-side representation of the
-	 * struct_ops type, including its nested data. For example:
-	 *
-	 *   struct bpf_struct_ops_tcp_congestion_ops {
-	 *       [... kernel internal fields ...]
-	 *       struct tcp_congestion_ops data;
-	 *   }
-	 *
-	 * In this case, len(kernVData) == sizeof(struct bpf_struct_ops_tcp_congestion_ops).
-	 * copyDataMember() will copy user-supplied data
-	 * into kernVData, which is then pushed into the map.
-	 */
-	kernVData []byte
-
-	// kernTypes describes the BTF types of the target struct_ops
-	// object and its nested members, used for resolving offsets
-	// and function pointer
-	kernTypes *structOpsKernTypes
-
-	// progAttachType maps program names to the sys.AttachType
-	// expected by the kernel when attaching each function pointer.
-	progAttachType map[string]sys.AttachType
-
-	// progAttachBtfID holds the BTF type ID of the struct_ops
-	// target in vmlinux
-	progAttachBtfID btf.TypeID
-}
-
 // 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.
@@ -136,43 +82,6 @@ func findStructTypeByNameFromModule(base *btf.Spec, name string) (*btf.Struct, *
 	return nil, nil, 0, btf.ErrNotFound
 }
 
-// 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(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)
-	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>)
-	vType, _, _, err := findStructTypeByName(s, valueType.Name)
-	if err != nil {
-		return nil, fmt.Errorf("kern struct type for %s %w", kType.TypeName(), err)
-	}
-
-	// 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)
-	}
-
-	return &structOpsKernTypes{
-		spec:        s,
-		typ:         kType,
-		typeID:      kID,
-		valueType:   vType,
-		modBtfObjId: uint32(modID),
-	}, nil
-}
-
 // getStructMemberIndexByName returns the index of `member` within struct `s` by
 // comparing the member name.
 func getStructMemberIndexByName(s *btf.Struct, name string) int {