struct_ops: switch to AttachTo for program binding

Replace use of structOpsProgMeta metadata with ProgramSpec.AttachTo
(e.g. "bpf_testmod_ops:test_1") to encode attach target,
and drop structOpsProgMeta, adjust tests accordingly.

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

Author: shun159

collection.go

@@ -839,12 +839,8 @@ func (cl *collectionLoader) copyDataMember(
 		structOps.progAttachType[ps.Name] = attachType
 		cl.stOpsProgsToMap[ps.Name] = ms.Name
 
-		// seed program with attach metadata (checked at load time)
-		ps.Instructions[0].Metadata.Set(structOpsProgMetaKey{}, &structOpsProgMeta{
-			attachBtfId: kern.typeID,
-			attachType:  attachType,
-			modBtfObjID: kern.modBtfObjId,
-		})
+		// set `AttachTo` for struct_ops prog; e.g. "bpf_testmod_ops:test_1"
+		ps.AttachTo = fmt.Sprintf("%s:%s", kern.typ.Name, memberName)
 	}
 
 	// Handle data member. copy data members from the user-defined struct to the kernel data buffer.

collection_test.go

@@ -778,8 +778,8 @@ func TestStructOpsMapSpecSimpleLoadAndAssign(t *testing.T) {
 
 	spec := &CollectionSpec{
 		Programs: map[string]*ProgramSpec{
-			"test_func_1": {
-				Name:    "test_func_1",
+			"test_1": {
+				Name:    "test_1",
 				Type:    StructOps,
 				License: "GPL",
 				Instructions: asm.Instructions{
@@ -801,7 +801,7 @@ func TestStructOpsMapSpecSimpleLoadAndAssign(t *testing.T) {
 					{Key: uint32(0), Value: structOpsMeta{
 						data: make([]byte, 448),
 						funcs: []structOpsFunc{
-							{"test_1", "test_func_1"},
+							{"test_1", "test_1"},
 						},
 					}},
 				},

prog.go

@@ -8,6 +8,7 @@ import (
 	"math"
 	"path/filepath"
 	"runtime"
+	"strings"
 	"time"
 
 	"github.com/cilium/ebpf/asm"
@@ -381,38 +382,66 @@ func newProgramWithOptions(spec *ProgramSpec, opts ProgramOptions, c *btf.Cache)
 		attr.AttachBtfObjFd = uint32(spec.AttachTarget.FD())
 		defer runtime.KeepAlive(spec.AttachTarget)
 	} else if spec.AttachTo != "" {
-		module, targetID, err := findProgramTargetInKernel(spec.AttachTo, spec.Type, spec.AttachType)
+		var targetMember string
+		var ok bool
+		attachTo := spec.AttachTo
+
+		if spec.Type == StructOps {
+			attachTo, targetMember, ok = strings.Cut(attachTo, ":")
+			if !ok || attachTo == "" || targetMember == "" {
+				return nil, fmt.Errorf("invalid AttachTo for StructOps (type:member): %q", spec.AttachTo)
+			}
+		}
+
+		module, targetID, err := findProgramTargetInKernel(attachTo, spec.Type, spec.AttachType)
 		if err != nil && !errors.Is(err, errUnrecognizedAttachType) {
 			// We ignore errUnrecognizedAttachType since AttachTo may be non-empty
 			// for programs that don't attach anywhere.
 			return nil, fmt.Errorf("attach %s/%s: %w", spec.Type, spec.AttachType, err)
 		}
 
 		attr.AttachBtfId = targetID
-		if module != nil {
-			attr.AttachBtfObjFd = uint32(module.FD())
-			defer module.Close()
-		}
-	}
+		if spec.Type == StructOps {
+			// we need to resolve `target` here, load the kernel spec
+			s, err := btf.LoadKernelSpec()
+			if err != nil {
+				return nil, fmt.Errorf("load vmlinux BTF: %w", err)
+			}
 
-	if spec.Type == StructOps {
-		if meta, ok := spec.Instructions[0].Metadata.Get(structOpsProgMetaKey{}).(*structOpsProgMeta); ok {
-			// set AttachBtfId / ExpectedAttachType from metadata
-			attr.AttachBtfId = sys.TypeID(meta.attachBtfId)
-			attr.ExpectedAttachType = meta.attachType
+			st, spec2, modBtfObjID, err := doFindStructTypeByName(s, attachTo)
+			fmt.Println("hogehogehogheoge", st, err)
+			if err != nil {
+				return nil, err
+			}
 
-			var modH *btf.Handle
-			if meta.modBtfObjID != 0 {
-				h, err := btf.NewHandleFromID(btf.ID(meta.modBtfObjID))
+			tid, err := spec2.TypeID(st)
+			if err != nil {
+				return nil, fmt.Errorf("type id for %s: %w", st.TypeName(), err)
+			}
+			attr.AttachBtfId = sys.TypeID(tid)
+
+			idx := getStructMemberIndexByName(st, targetMember)
+			fmt.Println(idx, "hogehogehoge")
+			if idx < 0 {
+				return nil, fmt.Errorf("member %q not found in %s", targetMember, st.Name)
+			}
+
+			attr.ExpectedAttachType = sys.AttachType(idx)
+
+			if modBtfObjID != 0 {
+				h, err := btf.NewHandleFromID(btf.ID(modBtfObjID))
 				if err != nil {
-					return nil, fmt.Errorf("open module BTF handle (id=%d): %w", meta.modBtfObjID, err)
+					return nil, fmt.Errorf("open module BTF handle (id=%d): %w", modBtfObjID, err)
 				}
-				modH = h
-				// set AttachBtfObjFd if the type comes from a module
+				defer h.Close()
 				attr.AttachBtfObjFd = uint32(h.FD())
-				defer modH.Close()
 			}
 		}
+
+		if module != nil {
+			attr.AttachBtfObjFd = uint32(module.FD())
+			defer module.Close()
+		}
 	}
 
 	if platform.IsWindows && opts.LogLevel != 0 {
@@ -1059,6 +1088,10 @@ func findProgramTargetInKernel(name string, progType ProgramType, attachType Att
 	)
 
 	switch (match{progType, attachType}) {
+	case match{StructOps, AttachStructOps}:
+		typeName = name
+		featureName = "struct_ops " + name
+		target = (*btf.Struct)(nil)
 	case match{LSM, AttachLSMMac}:
 		typeName = "bpf_lsm_" + name
 		featureName = name + " LSM hook"

struct_ops.go

@@ -10,14 +10,6 @@ import (
 
 const structOpsValuePrefix = "bpf_struct_ops_"
 
-// TODO: Doc
-type structOpsProgMetaKey struct{}
-type structOpsProgMeta struct {
-	attachBtfId btf.TypeID
-	attachType  sys.AttachType
-	modBtfObjID uint32
-}
-
 // structOpsKernTypes groups all kernel-side BTF artefacts that belong to a
 // resolved struct_ops.
 type structOpsKernTypes struct {
@@ -161,6 +153,10 @@ func findStructTypeByName(s *btf.Spec, typ *btf.Struct) (*btf.Struct, *btf.Spec,
 	return doFindStructTypeByName(s, typ.TypeName())
 }
 
+func findStructTypeByName2(s *btf.Spec, name string) (*btf.Struct, *btf.Spec, uint32, error) {
+	return doFindStructTypeByName(s, name)
+}
+
 // doFindStructTypeByName 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.
@@ -221,6 +217,7 @@ func findStructTypeByNameFromModule(base *btf.Spec, name string) (*btf.Struct, *
 		if errors.Is(err, btf.ErrNotFound) {
 			continue
 		}
+
 		if err != nil {
 			return nil, nil, 0, fmt.Errorf("lookup type in module %s: %w", info.Name, err)
 		}
@@ -332,6 +329,17 @@ func getStructMemberIndexOf(s *btf.Struct, member btf.Member) int {
 	return -1
 }
 
+// getStructMemberIndexByName returns the index of `member` within struct `s` by
+// comparing the member name.
+func getStructMemberIndexByName(s *btf.Struct, name string) int {
+	for idx, m := range s.Members {
+		if m.Name == name {
+			return idx
+		}
+	}
+	return -1
+}
+
 // check if the buffer is filled with 0
 func isMemoryZero(p []byte) bool {
 	for _, b := range p {