struct_ops: fix to use cached BTF for find struct_ops struct

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

Author: shun159

collection.go

@@ -517,7 +517,7 @@ func (cl *collectionLoader) loadMap(mapName string) (*Map, error) {
 		return m, nil
 	}
 
-	m, err := newMapWithOptions(mapSpec, cl.opts.Maps)
+	m, err := newMapWithOptions(mapSpec, cl.opts.Maps, cl.types)
 	if err != nil {
 		return nil, fmt.Errorf("map %s: %w", mapName, err)
 	}
@@ -705,13 +705,8 @@ func (cl *collectionLoader) populateDeferredMaps() error {
 				return fmt.Errorf("value should be an array of byte")
 			}
 
-			s, err := btf.LoadKernelSpec()
-			if err != nil {
-				return fmt.Errorf("load vmlinux BTF: %w", err)
-			}
-
 			target := btf.Type((*btf.Struct)(nil))
-			_, module, err := findTargetInKernel(s, valueType.Name, &target)
+			_, module, err := findTargetInKernel(valueType.Name, &target, cl.types)
 			if err != nil {
 				return fmt.Errorf("lookup value type %q: %w", valueType.Name, err)
 			}
@@ -841,11 +836,6 @@ 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
@@ -864,7 +854,7 @@ func (cl *collectionLoader) initKernStructOps() error {
 		kTypeName := strings.TrimPrefix(vType.Name, structOpsValuePrefix)
 
 		target := btf.Type((*btf.Struct)(nil))
-		_, module, err := findTargetInKernel(s, kTypeName, &target)
+		_, module, err := findTargetInKernel(kTypeName, &target, cl.types)
 		if err != nil {
 			return fmt.Errorf("lookup kern type %q: %w", kTypeName, err)
 		}

collection_test.go

@@ -804,13 +804,8 @@ func TestStructOpsMapSpecSimpleLoadAndAssign(t *testing.T) {
 		},
 	}
 
-	s, err := btf.LoadKernelSpec()
-	if err != nil {
-		t.Fatal(err)
-	}
-
 	target := btf.Type((*btf.Struct)(nil))
-	_, module, err := findTargetInKernel(s, "bpf_struct_ops_bpf_testmod_ops", &target)
+	_, module, err := findTargetInKernel("bpf_struct_ops_bpf_testmod_ops", &target, btf.NewCache())
 	if errors.Is(err, btf.ErrNotFound) {
 		t.Skip("bpf_testmod_ops not loaded")
 	}

map.go

@@ -334,7 +334,7 @@ func NewMap(spec *MapSpec) (*Map, error) {
 //
 // May return an error wrapping ErrMapIncompatible.
 func NewMapWithOptions(spec *MapSpec, opts MapOptions) (*Map, error) {
-	m, err := newMapWithOptions(spec, opts)
+	m, err := newMapWithOptions(spec, opts, btf.NewCache())
 	if err != nil {
 		return nil, fmt.Errorf("creating map: %w", err)
 	}
@@ -347,7 +347,7 @@ func NewMapWithOptions(spec *MapSpec, opts MapOptions) (*Map, error) {
 	return m, nil
 }
 
-func newMapWithOptions(spec *MapSpec, opts MapOptions) (_ *Map, err error) {
+func newMapWithOptions(spec *MapSpec, opts MapOptions, c *btf.Cache) (_ *Map, err error) {
 	closeOnError := func(c io.Closer) {
 		if err != nil {
 			c.Close()
@@ -397,7 +397,7 @@ func newMapWithOptions(spec *MapSpec, opts MapOptions) (_ *Map, err error) {
 			return nil, errors.New("inner maps cannot be pinned")
 		}
 
-		template, err := spec.InnerMap.createMap(nil)
+		template, err := spec.InnerMap.createMap(nil, c)
 		if err != nil {
 			return nil, fmt.Errorf("inner map: %w", err)
 		}
@@ -409,7 +409,7 @@ func newMapWithOptions(spec *MapSpec, opts MapOptions) (_ *Map, err error) {
 		innerFd = template.fd
 	}
 
-	m, err := spec.createMap(innerFd)
+	m, err := spec.createMap(innerFd, c)
 	if err != nil {
 		return nil, err
 	}
@@ -504,7 +504,7 @@ func (m *Map) memorySize() (int, error) {
 
 // createMap validates the spec's properties and creates the map in the kernel
 // using the given opts. It does not populate or freeze the map.
-func (spec *MapSpec) createMap(inner *sys.FD) (_ *Map, err error) {
+func (spec *MapSpec) createMap(inner *sys.FD, c *btf.Cache) (_ *Map, err error) {
 	closeOnError := func(closer io.Closer) {
 		if err != nil {
 			closer.Close()
@@ -555,11 +555,6 @@ func (spec *MapSpec) createMap(inner *sys.FD) (_ *Map, err error) {
 			}
 			defer h.Close()
 
-			s, err := btf.LoadKernelSpec()
-			if err != nil {
-				return nil, fmt.Errorf("open vmlinux BTF: %w", err)
-			}
-
 			if spec.Value == nil {
 				return nil, fmt.Errorf("struct type is not specified as Value")
 			}
@@ -572,7 +567,7 @@ func (spec *MapSpec) createMap(inner *sys.FD) (_ *Map, err error) {
 			// struct_ops: resolve value type ("bpf_struct_ops_<name>") and
 			// record kernel-specific BTF IDs / FDs needed for map creation.
 			target := btf.Type((*btf.Struct)(nil))
-			s, module, err := findTargetInKernel(s, valueType.Name, &target)
+			s, module, err := findTargetInKernel(valueType.Name, &target, c)
 			if err != nil {
 				return nil, fmt.Errorf("lookup value type %q: %w", valueType.Name, err)
 			}

prog.go

@@ -402,14 +402,8 @@ func newProgramWithOptions(spec *ProgramSpec, opts ProgramOptions, c *btf.Cache)
 
 		attr.AttachBtfId = targetID
 		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)
-			}
-
 			target := btf.Type((*btf.Struct)(nil))
-			s, module, err := findTargetInKernel(s, attachTo, &target)
+			s, module, err := findTargetInKernel(attachTo, &target, c)
 			if err != nil {
 				return nil, fmt.Errorf("lookup struct_ops kern type %q: %w", attachTo, err)
 			}

struct_ops_test.go

@@ -28,13 +28,8 @@ func TestCreateStructOpsMapSpecSimple(t *testing.T) {
 		},
 	}
 
-	s, err := btf.LoadKernelSpec()
-	if err != nil {
-		t.Fatal(err)
-	}
-
 	target := btf.Type((*btf.Struct)(nil))
-	_, module, err := findTargetInKernel(s, "bpf_struct_ops_bpf_testmod_ops", &target)
+	_, module, err := findTargetInKernel("bpf_struct_ops_bpf_testmod_ops", &target, btf.NewCache())
 	if errors.Is(err, btf.ErrNotFound) {
 		t.Skip("bpf_testmod_ops not loaded")
 	}