struct_ops: implement onProgramLoaded() and postLoad()

1. implemented the above functions so that build kern_vdata
2. support "mod_btf" handling for testing
3. fix newProgramWithOptions() so that load structOps programs
4. fix createMap() so that find struct types from mod_btf

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

Author: shun159

collection.go

@@ -309,7 +309,7 @@ func (cs *CollectionSpec) LoadAndAssign(to interface{}, opts *CollectionOptions)
 	}
 
 	// load programs to struct_ops maps
-	if err := loader.stOps.postLoad(loader.maps); err != nil {
+	if err := loader.stOps.postLoad(loader.maps, loader.programs); err != nil {
 		return err
 	}
 
@@ -595,7 +595,7 @@ func (cl *collectionLoader) loadProgram(progName string) (*Program, error) {
 	cl.programs[progName] = prog
 
 	if prog.Type() == StructOps {
-		if err := cl.stOps.onProgramLoaded(prog, progSpec, cl.coll); err != nil {
+		if err := cl.stOps.onProgramLoaded(prog, progSpec); err != nil {
 			return nil, err
 		}
 	}

collection_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/cilium/ebpf/asm"
 	"github.com/cilium/ebpf/btf"
 	"github.com/cilium/ebpf/internal"
+	"github.com/cilium/ebpf/internal/sys"
 	"github.com/cilium/ebpf/internal/testutils"
 	"github.com/cilium/ebpf/internal/testutils/testmain"
 )
@@ -776,27 +777,42 @@ func TestStructOpsMapSpecSimpleLoadAndAssign(t *testing.T) {
 	requireStructOpsDummy(t)
 
 	spec := &CollectionSpec{
+		Programs: map[string]*ProgramSpec{
+			"dummy_test_1": {
+				Name:    "dummy_test_1",
+				Type:    StructOps,
+				License: "GPL",
+				Instructions: asm.Instructions{
+					asm.Mov.Imm(asm.R0, 0),
+					asm.Return(),
+				},
+			},
+		},
 		Maps: map[string]*MapSpec{
 			// TODO: we should use "bpf_testmod_ops" for this case (tentative test case)
 			"dummy_ops": {
 				Name:       "dummy_ops",
 				Type:       StructOpsMap,
+				Flags:      sys.BPF_F_LINK,
 				KeySize:    4,
-				ValueSize:  128,
+				ValueSize:  448,
 				MaxEntries: 1,
-				Value:      &btf.Struct{Name: "bpf_dummy_ops"},
+				Value:      &btf.Struct{Name: "bpf_testmod_ops"},
 				Contents: []MapKV{
 					{Key: uint32(0), Value: structOpsMeta{
-						data:  make([]byte, 128),
-						funcs: []structOpsFunc{},
+						data: make([]byte, 448),
+						funcs: []structOpsFunc{
+							{"test_1", "dummy_test_1"},
+						},
 					}},
 				},
 			},
 		},
 	}
 
 	var obj struct {
-		DummyOps *Map `ebpf:"dummy_ops"`
+		DummyTest1 *Program `ebpf:"dummy_test_1"`
+		DummyOps   *Map     `ebpf:"dummy_ops"`
 	}
 
 	err := spec.LoadAndAssign(&obj, nil)

map.go

@@ -569,20 +569,12 @@ func (spec *MapSpec) createMap(inner *sys.FD) (_ *Map, err error) {
 				return nil, fmt.Errorf("struct type is not specified as Value")
 			}
 
-			userStructTypeName := spec.Value.TypeName()
-			t, err := s.AnyTypeByName(structOpsValuePrefix + userStructTypeName)
-			if errors.Is(err, btf.ErrNotFound) {
-				return nil, fmt.Errorf("struct_ops kernel type %q: %w", userStructTypeName, btf.ErrNotFound)
-			}
-			if err != nil {
-				return nil, fmt.Errorf("lookup kernel type %q: %w", userStructTypeName, err)
-			}
-
-			userStructType, ok := t.(*btf.Struct)
+			userStType, ok := spec.Value.(*btf.Struct)
 			if !ok {
 				return nil, fmt.Errorf("value must be Struct type")
 			}
 
+			userStructType, s, modBtfObjId, err := findStructByNameWithPrefix(s, userStType)
 			btfValueTypeId, err := s.TypeID(userStructType)
 			if err != nil {
 				return nil, fmt.Errorf("lookup type_id: %w", err)
@@ -591,6 +583,16 @@ func (spec *MapSpec) createMap(inner *sys.FD) (_ *Map, err error) {
 			attr.ValueSize = spec.ValueSize
 			attr.BtfVmlinuxValueTypeId = btfValueTypeId
 			attr.BtfFd = uint32(h.FD())
+
+			if modBtfObjId != 0 {
+				attr.MapFlags |= sys.BPF_F_VTYPE_BTF_OBJ_FD
+				modH, err := btf.NewHandleFromID(btf.ID(modBtfObjId))
+				if err != nil {
+					return nil, fmt.Errorf("open module BTF (id=%d): %w", modBtfObjId, err)
+				}
+				attr.ValueTypeBtfObjFd = int32(modH.FD())
+				defer modH.Close()
+			}
 		} else {
 			handle, keyTypeID, valueTypeID, err := btf.MarshalMapKV(spec.Key, spec.Value)
 			if err != nil && !errors.Is(err, btf.ErrNotSupported) {

prog.go

@@ -395,6 +395,24 @@ func newProgramWithOptions(spec *ProgramSpec, opts ProgramOptions, c *btf.Cache)
 		}
 	}
 
+	if spec.Type == StructOps {
+		if meta, ok := spec.Instructions[0].Metadata.Get(structOpsProgMetaKey{}).(*structOpsProgMeta); ok {
+			attr.AttachBtfId = sys.TypeID(meta.AttachBtfId)
+			attr.ExpectedAttachType = meta.AttachType
+
+			var modH *btf.Handle
+			if meta.ModBtfObjID != 0 {
+				h, err := btf.NewHandleFromID(btf.ID(meta.ModBtfObjID))
+				if err != nil {
+					return nil, fmt.Errorf("open module BTF handle (id=%d): %w", meta.ModBtfObjID, err)
+				}
+				modH = h
+				attr.AttachBtfObjFd = uint32(h.FD())
+				defer modH.Close()
+			}
+		}
+	}
+
 	if platform.IsWindows && opts.LogLevel != 0 {
 		return nil, fmt.Errorf("log level: %w", internal.ErrNotSupportedOnOS)
 	}