program: Allow passing extra targets for CO-RE relocations

This commit introduces a new ExtraRelocationTargets field on ProgramOptions
to llow users to pass additional targets (besides the kernel types) to
perform CO-RE relocations. The KernelModuleTypes field is removed as
ExtraRelocationTargets covers its functionality.

This is used in Inspektor Gadget to perform relocations against a
shared map that contains fields whose sizes change according to the
runtime configuration.

Signed-off-by: Mauricio Vásquez <[email protected]>

Author: mauriciovasquezbernal

btf/core_reloc_test.go

@@ -36,8 +36,7 @@ func TestCORERelocationLoad(t *testing.T) {
 			}
 
 			prog, err := ebpf.NewProgramWithOptions(progSpec, ebpf.ProgramOptions{
-				KernelTypes:       spec.Types,
-				KernelModuleTypes: map[string]*btf.Spec{},
+				KernelTypes: spec.Types,
 			})
 			testutils.SkipIfNotSupported(t, err)
 
@@ -81,28 +80,45 @@ func TestCORERelocationRead(t *testing.T) {
 		t.Fatal(err)
 	}
 
+	tests := []struct {
+		name string
+		opts ebpf.ProgramOptions
+	}{
+		{
+			name: "KernelTypes",
+			opts: ebpf.ProgramOptions{
+				KernelTypes: targetSpec,
+			},
+		},
+		{
+			name: "ExtraRelocationTargets",
+			opts: ebpf.ProgramOptions{
+				ExtraRelocationTargets: []*btf.Spec{targetSpec},
+			},
+		},
+	}
+
 	for _, progSpec := range spec.Programs {
-		t.Run(progSpec.Name, func(t *testing.T) {
-			prog, err := ebpf.NewProgramWithOptions(progSpec, ebpf.ProgramOptions{
-				KernelTypes:       targetSpec,
-				KernelModuleTypes: map[string]*btf.Spec{},
-			})
-			testutils.SkipIfNotSupported(t, err)
-			if err != nil {
-				t.Fatal("Load program:", err)
-			}
-			defer prog.Close()
+		for _, test := range tests {
+			t.Run(progSpec.Name+"_"+test.name, func(t *testing.T) {
+				prog, err := ebpf.NewProgramWithOptions(progSpec, test.opts)
+				testutils.SkipIfNotSupported(t, err)
+				if err != nil {
+					t.Fatal("Load program:", err)
+				}
+				defer prog.Close()
 
-			ret, _, err := prog.Test(internal.EmptyBPFContext)
-			testutils.SkipIfNotSupported(t, err)
-			if err != nil {
-				t.Fatal("Error when running:", err)
-			}
+				ret, _, err := prog.Test(internal.EmptyBPFContext)
+				testutils.SkipIfNotSupported(t, err)
+				if err != nil {
+					t.Fatal("Error when running:", err)
+				}
 
-			if ret != 0 {
-				t.Error("Assertion failed on line", ret)
-			}
-		})
+				if ret != 0 {
+					t.Error("Assertion failed on line", ret)
+				}
+			})
+		}
 	}
 }
 
@@ -151,8 +167,7 @@ func TestCOREPoisonLineInfo(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			t.Log(progSpec.Instructions)
 			_, err := ebpf.NewProgramWithOptions(progSpec, ebpf.ProgramOptions{
-				KernelTypes:       empty,
-				KernelModuleTypes: map[string]*btf.Spec{},
+				KernelTypes: empty,
 			})
 			testutils.SkipIfNotSupported(t, err)
 

elf_reader_test.go

@@ -1130,7 +1130,6 @@ func TestLibBPFCompat(t *testing.T) {
 
 				opts := opts // copy
 				opts.Programs.KernelTypes = btfSpec
-				opts.Programs.KernelModuleTypes = map[string]*btf.Spec{}
 				load(t, spec, opts, valid)
 			})
 		}

linker.go

@@ -124,7 +124,7 @@ func hasFunctionReferences(insns asm.Instructions) bool {
 //
 // Passing a nil target will relocate against the running kernel. insns are
 // modified in place.
-func applyRelocations(insns asm.Instructions, bo binary.ByteOrder, b *btf.Builder, c *btf.Cache) error {
+func applyRelocations(insns asm.Instructions, bo binary.ByteOrder, b *btf.Builder, c *btf.Cache, extraTargets []*btf.Spec) error {
 	var relos []*btf.CORERelocation
 	var reloInsns []*asm.Instruction
 	iter := insns.Iterate()
@@ -155,7 +155,7 @@ func applyRelocations(insns asm.Instructions, bo binary.ByteOrder, b *btf.Builde
 		return err
 	}
 
-	targets := make([]*btf.Spec, 0, 1+len(modules))
+	targets := make([]*btf.Spec, 0, 1+len(modules)+len(extraTargets))
 	targets = append(targets, kernelTarget)
 
 	for _, kmod := range modules {
@@ -167,6 +167,8 @@ func applyRelocations(insns asm.Instructions, bo binary.ByteOrder, b *btf.Builde
 		targets = append(targets, spec)
 	}
 
+	targets = append(targets, extraTargets...)
+
 	fixups, err := btf.CORERelocate(relos, targets, bo, b.Add)
 	if err != nil {
 		return err

prog.go

@@ -8,7 +8,6 @@ import (
 	"math"
 	"path/filepath"
 	"runtime"
-	"sort"
 	"time"
 
 	"github.com/cilium/ebpf/asm"
@@ -95,13 +94,10 @@ type ProgramOptions struct {
 	// use the kernel BTF from a well-known location if nil.
 	KernelTypes *btf.Spec
 
-	// Type information used for CO-RE relocations of kernel modules,
-	// indexed by module name.
-	//
-	// This is useful in environments where the kernel BTF is not available
-	// (containers) or where it is in a non-standard location. Defaults to
-	// use the kernel module BTF from a well-known location if nil.
-	KernelModuleTypes map[string]*btf.Spec
+	// Additional targets to consider for CO-RE relocations. This can be used to
+	// pass BTF information for kernel modules when it's not present on
+	// KernelTypes.
+	ExtraRelocationTargets []*btf.Spec
 }
 
 // ProgramSpec defines a Program.
@@ -293,7 +289,7 @@ func newProgramWithOptions(spec *ProgramSpec, opts ProgramOptions, c *btf.Cache)
 	copy(insns, spec.Instructions)
 
 	var b btf.Builder
-	if err := applyRelocations(insns, spec.ByteOrder, &b, c); err != nil {
+	if err := applyRelocations(insns, spec.ByteOrder, &b, c, opts.ExtraRelocationTargets); err != nil {
 		return nil, fmt.Errorf("apply CO-RE relocations: %w", err)
 	}
 
@@ -1202,14 +1198,7 @@ func newBTFCache(opts *ProgramOptions) *btf.Cache {
 	c := btf.NewCache()
 	if opts.KernelTypes != nil {
 		c.KernelTypes = opts.KernelTypes
-		c.ModuleTypes = opts.KernelModuleTypes
-		if opts.KernelModuleTypes != nil {
-			c.LoadedModules = []string{}
-			for name := range opts.KernelModuleTypes {
-				c.LoadedModules = append(c.LoadedModules, name)
-			}
-			sort.Strings(c.LoadedModules)
-		}
+		c.LoadedModules = []string{}
 	}
 	return c
 }

prog_test.go

@@ -881,8 +881,7 @@ func TestProgramLoadErrors(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			t.Log(progSpec.Instructions)
 			_, err := newProgram(t, progSpec, &ProgramOptions{
-				KernelTypes:       empty,
-				KernelModuleTypes: map[string]*btf.Spec{},
+				KernelTypes: empty,
 			})
 			testutils.SkipIfNotSupported(t, err)