struct_ops: Add struct_ops loader

- Add a smoke test for LoadAndAssign with a StructOpsMap (skips on unsupported kernels)
- Call stOps.preLoad / .onProgramLoaded / .postLoad from LoadAndAssign
- postLoad: no-op for now; value population will follow

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

Author: shun159

collection.go

@@ -268,6 +268,11 @@ func (cs *CollectionSpec) LoadAndAssign(to interface{}, opts *CollectionOptions)
 	}
 	defer loader.close()
 
+	// initialize struct_ops maps
+	if err := loader.stOps.preLoad(loader.coll); err != nil {
+		return err
+	}
+
 	// Support assigning Programs and Maps, lazy-loading the required objects.
 	assignedMaps := make(map[string]bool)
 	assignedProgs := make(map[string]bool)
@@ -303,6 +308,11 @@ func (cs *CollectionSpec) LoadAndAssign(to interface{}, opts *CollectionOptions)
 		return err
 	}
 
+	// load programs to struct_ops maps
+	if err := loader.stOps.postLoad(loader.maps); err != nil {
+		return err
+	}
+
 	// Evaluate the loader's objects after all (lazy)loading has taken place.
 	for n, m := range loader.maps {
 		if m.typ.canStoreProgram() {
@@ -413,6 +423,7 @@ type collectionLoader struct {
 	programs map[string]*Program
 	vars     map[string]*Variable
 	types    *btf.Cache
+	stOps    *structOpsLoader
 }
 
 func newCollectionLoader(coll *CollectionSpec, opts *CollectionOptions) (*collectionLoader, error) {
@@ -438,6 +449,7 @@ func newCollectionLoader(coll *CollectionSpec, opts *CollectionOptions) (*collec
 		make(map[string]*Program),
 		make(map[string]*Variable),
 		newBTFCache(&opts.Programs),
+		newStructOpsLoader(),
 	}, nil
 }
 
@@ -581,6 +593,13 @@ 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 {
+			return nil, err
+		}
+	}
+
 	return prog, nil
 }
 

collection_test.go

@@ -771,3 +771,40 @@ func ExampleCollectionSpec_LoadAndAssign() {
 	defer objs.Program.Close()
 	defer objs.Map.Close()
 }
+
+func TestStructOpsMapSpecSimpleLoadAndAssign(t *testing.T) {
+	requireStructOpsDummy(t)
+
+	spec := &CollectionSpec{
+		Maps: map[string]*MapSpec{
+			"dummy_ops": {
+				Name:       "dummy_ops",
+				Type:       StructOpsMap,
+				KeySize:    4,
+				ValueSize:  128,
+				MaxEntries: 1,
+				Contents: []MapKV{
+					{Key: uint32(0), Value: structOpsMeta{
+						userTypeName: "bpf_dummy_ops",
+						kernTypeName: "bpf_struct_ops_bpf_dummy_ops",
+					}},
+				},
+			},
+		},
+	}
+
+	var obj struct {
+		DummyOps *Map `ebpf:"dummy_ops"`
+	}
+
+	err := spec.LoadAndAssign(&obj, nil)
+	testutils.SkipIfNotSupported(t, err)
+	if err != nil {
+		t.Fatalf("LoadAndAssign failed: %v", err)
+	}
+	t.Cleanup(func() { _ = obj.DummyOps.Close() })
+
+	if obj.DummyOps == nil {
+		t.Fatal("DummyOps not assigned")
+	}
+}

struct_ops.go

@@ -32,3 +32,41 @@ func extractStructOpsMeta(contents []MapKV) (*structOpsMeta, error) {
 
 	return &meta, nil
 }
+
+type structOpsLoader struct {
+	metas       map[string]*structOpsMeta
+	specCopy    map[string]*MapSpec
+	progsByName map[string]*Program
+}
+
+func newStructOpsLoader() *structOpsLoader {
+	return &structOpsLoader{
+		metas:       make(map[string]*structOpsMeta),
+		specCopy:    make(map[string]*MapSpec),
+		progsByName: make(map[string]*Program),
+	}
+}
+
+// preLoad collects typed metadata for struct_ops maps from the CollectionSpec.
+// It does not modify specs nor create kernel objects. Value population happens in a follow-up PR.
+func (sl *structOpsLoader) preLoad(cs *CollectionSpec) error {
+	return nil
+}
+
+// onProgramLoaded is called right after a Program has been successfully
+// loaded by collectionLoader.loadProgram().  If the program belongs to a
+// struct_ops map it records the program for later FD injection.
+func (sl *structOpsLoader) onProgramLoaded(p *Program, ps *ProgramSpec, cs *CollectionSpec) error {
+	if ps.Type != StructOps {
+		return nil
+	}
+	sl.progsByName[ps.Name] = p
+	return nil
+}
+
+// onProgramLoaded is called right after a Program has been successfully
+// loaded by collectionLoader.loadProgram().  If the program belongs to a
+// struct_ops map it records the program for later FD injection.
+func (sl *structOpsLoader) postLoad(loadedMaps map[string]*Map) error {
+	return nil
+}