elf_reader: add struct_ops support

This commit adds struct_ops support to the ELF reader: it classifies non-executable PROGBITS sections,
parses their BTF Datasec to build MapSpecs, associates relocs with func-pointer members to
set ps.AttachTo, and adds TestStructOps.

Related: cilium#1845

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

Author: shun159

Makefile

@@ -50,6 +50,7 @@ TARGETS := \
 	testdata/errors \
 	testdata/variables \
 	testdata/arena \
+	testdata/struct_ops \
 	btf/testdata/relocs \
 	btf/testdata/relocs_read \
 	btf/testdata/relocs_read_tgt \

elf_reader.go

@@ -41,20 +41,30 @@ type ksymMeta struct {
 	Name    string
 }
 
+type structOpsSpec struct {
+	name string
+	// section index of .struct_ops / .struct_ops.link
+	secIdx elf.SectionIndex
+	// byte offset of the variable in that section
+	userOff  uint64
+	userSize uint64
+}
+
 // elfCode is a convenience to reduce the amount of arguments that have to
 // be passed around explicitly. You should treat its contents as immutable.
 type elfCode struct {
 	*internal.SafeELFFile
-	sections map[elf.SectionIndex]*elfSection
-	license  string
-	version  uint32
-	btf      *btf.Spec
-	extInfo  *btf.ExtInfos
-	maps     map[string]*MapSpec
-	vars     map[string]*VariableSpec
-	kfuncs   map[string]*btf.Func
-	ksyms    map[string]struct{}
-	kconfig  *MapSpec
+	sections  map[elf.SectionIndex]*elfSection
+	license   string
+	version   uint32
+	btf       *btf.Spec
+	extInfo   *btf.ExtInfos
+	maps      map[string]*MapSpec
+	vars      map[string]*VariableSpec
+	kfuncs    map[string]*btf.Func
+	ksyms     map[string]struct{}
+	kconfig   *MapSpec
+	structOps map[string]*structOpsSpec
 }
 
 // LoadCollectionSpec parses an ELF file into a CollectionSpec.
@@ -116,8 +126,15 @@ func LoadCollectionSpecFromReader(rd io.ReaderAt) (*CollectionSpec, error) {
 		case sec.Type == elf.SHT_REL:
 			// Store relocations under the section index of the target
 			relSections[elf.SectionIndex(sec.Info)] = sec
-		case sec.Type == elf.SHT_PROGBITS && (sec.Flags&elf.SHF_EXECINSTR) != 0 && sec.Size > 0:
-			sections[idx] = newElfSection(sec, programSection)
+		case sec.Type == elf.SHT_PROGBITS:
+			if (sec.Flags&elf.SHF_EXECINSTR) != 0 && sec.Size > 0 {
+				sections[idx] = newElfSection(sec, programSection)
+			} else if sec.Name == ".struct_ops" || sec.Name == ".struct_ops.link" {
+				//classification based on sec names so that struct_ops-specific
+				// sections (.struct_ops, .struct_ops.link) are correctly recognized
+				// as non-executable PROGBITS, allowing value placement and link metadata to be loaded.
+				sections[idx] = newElfSection(sec, structOpsSection)
+			}
 		}
 	}
 
@@ -147,6 +164,7 @@ func LoadCollectionSpecFromReader(rd io.ReaderAt) (*CollectionSpec, error) {
 		vars:        make(map[string]*VariableSpec),
 		kfuncs:      make(map[string]*btf.Func),
 		ksyms:       make(map[string]struct{}),
+		structOps:   make(map[string]*structOpsSpec),
 	}
 
 	symbols, err := f.Symbols()
@@ -164,6 +182,10 @@ func LoadCollectionSpecFromReader(rd io.ReaderAt) (*CollectionSpec, error) {
 		return nil, fmt.Errorf("load maps: %w", err)
 	}
 
+	if err := ec.loadStructOpsMaps(); err != nil {
+		return nil, fmt.Errorf("struct_ops maps: %w", err)
+	}
+
 	if err := ec.loadBTFMaps(); err != nil {
 		return nil, fmt.Errorf("load BTF maps: %w", err)
 	}
@@ -186,6 +208,15 @@ func LoadCollectionSpecFromReader(rd io.ReaderAt) (*CollectionSpec, error) {
 		return nil, fmt.Errorf("load programs: %w", err)
 	}
 
+	// assiociate members in structs with ProgramSpecs using relo
+	if err := ec.associateStructOpsRelocs(
+		progs,
+		relSections,
+		symbols,
+	); err != nil {
+		return nil, fmt.Errorf("load struct_ops: %w", err)
+	}
+
 	return &CollectionSpec{
 		ec.maps,
 		progs,
@@ -239,6 +270,7 @@ const (
 	btfMapSection
 	programSection
 	dataSection
+	structOpsSection
 )
 
 type elfSection struct {
@@ -349,6 +381,10 @@ func (ec *elfCode) loadProgramSections() (map[string]*ProgramSpec, error) {
 			continue
 		}
 
+		if !(sec.Type == elf.SHT_PROGBITS && (sec.Flags&elf.SHF_EXECINSTR) != 0) {
+			continue
+		}
+
 		if len(sec.symbols) == 0 {
 			return nil, fmt.Errorf("section %v: missing symbols", sec.Name)
 		}
@@ -564,7 +600,7 @@ func (ec *elfCode) relocateInstruction(ins *asm.Instruction, rel elf.Symbol) err
 		ins.Constant = int64(uint64(offset) << 32)
 		ins.Src = asm.PseudoMapValue
 
-	case programSection:
+	case programSection, structOpsSection:
 		switch opCode := ins.OpCode; {
 		case opCode.JumpOp() == asm.Call:
 			if ins.Src != asm.PseudoCall {
@@ -1379,6 +1415,163 @@ func (ec *elfCode) loadKsymsSection() error {
 	return nil
 }
 
+// loadStructOpsMapsFromSections creates StructOps MapSpecs from DataSec sections
+// ".struct_ops" and ".struct_ops.link" found in the object BTF.
+func (ec *elfCode) loadStructOpsMaps() error {
+	for secIdx, sec := range ec.sections {
+		if sec.kind != structOpsSection {
+			continue
+		}
+
+		// Process the struct_ops section to create the map
+		dataType, err := ec.btf.AnyTypeByName(sec.Name)
+		if err != nil {
+			return fmt.Errorf("datasec %s: %w", sec.Name, err)
+		}
+
+		dataSec, ok := btf.As[*btf.Datasec](dataType)
+		if !ok {
+			return fmt.Errorf("%s BTF is not a Datasec", sec.Name)
+		}
+
+		for _, vsi := range dataSec.Vars {
+			varType, ok := btf.As[*btf.Var](vsi.Type)
+			if !ok {
+				return fmt.Errorf("var type in %s: want *btf.Var, got %T", sec.Name, btf.UnderlyingType(vsi.Type))
+			}
+			mapName := varType.Name
+
+			userType, ok := btf.UnderlyingType(varType.Type).(*btf.Struct)
+			if !ok {
+				return fmt.Errorf("var %s: expect struct, got %T", varType.Name, varType.Type)
+			}
+
+			// Retrieve raw data from the ELF section.
+			// This data contains the initial values for the struct_ops map.
+			userData, err := sec.Data()
+			if err != nil {
+				return fmt.Errorf("failed to read section data: %w", err)
+			}
+
+			flags := uint32(0)
+			if sec.Name == ".struct_ops.link" {
+				flags = sys.BPF_F_LINK
+			}
+
+			userSize := uint64(userType.Size)
+			userOff := uint64(vsi.Offset)
+			if userOff+userSize > uint64(len(userData)) {
+				return fmt.Errorf("%s exceeds section", mapName)
+			}
+
+			ec.structOps[mapName] =
+				&structOpsSpec{
+					name:     mapName,
+					secIdx:   secIdx,
+					userOff:  userOff,
+					userSize: userSize,
+				}
+
+			ec.maps[mapName] =
+				&MapSpec{
+					Name:       mapName,
+					Type:       StructOpsMap,
+					Key:        &btf.Int{Size: 4},
+					Value:      userType,
+					Flags:      flags,
+					MaxEntries: 1,
+					Contents: []MapKV{
+						{
+							Key:   uint32(0),
+							Value: append([]byte(nil), userData[userOff:userOff+userSize]...),
+						},
+					},
+				}
+		}
+	}
+
+	return nil
+}
+
+// associateStructOpsRelocs handles `.struct_ops(.link)`
+// and associates the target function with the correct struct member in the map.
+func (ec *elfCode) associateStructOpsRelocs(
+	progs map[string]*ProgramSpec,
+	relSecs map[elf.SectionIndex]*elf.Section,
+	symbols []elf.Symbol,
+) error {
+	for _, sec := range relSecs {
+		if !strings.HasPrefix(sec.Name, ".rel") {
+			continue
+		}
+
+		targetIdx := elf.SectionIndex(sec.Info)
+		targetSec, ok := ec.sections[targetIdx]
+		if !(ok && strings.HasPrefix(targetSec.Name, ".struct_ops")) {
+			continue
+		}
+
+		// Load the relocations from the relocation section
+		rels, err := ec.loadSectionRelocations(sec, symbols)
+		if err != nil {
+			return fmt.Errorf("failed to load relocations for section %s: %w", sec.Name, err)
+		}
+
+		for relOff, sym := range rels {
+			var ms *MapSpec
+			var meta *structOpsSpec
+
+			for _, mapSpec := range ec.maps {
+				if mapSpec.Type != StructOpsMap || len(mapSpec.Contents) == 0 {
+					continue
+				}
+
+				stOps, ok := ec.structOps[mapSpec.Name]
+				if !ok {
+					continue
+				}
+
+				if uint64(targetIdx) == uint64(stOps.secIdx) &&
+					stOps.userOff <= relOff &&
+					(relOff-stOps.userOff) < stOps.userSize {
+					meta = stOps
+					ms = mapSpec
+				}
+			}
+
+			if ms == nil {
+				return fmt.Errorf("no struct_ops map found for secIdx %d and relOffset %d", targetIdx, relOff)
+			}
+
+			moff := btf.Bits((relOff - meta.userOff) * 8)
+
+			userSt, ok := btf.As[*btf.Struct](ms.Value)
+			if !ok {
+				return fmt.Errorf("provided value is not a btf.Struct")
+			}
+
+			for _, m := range userSt.Members {
+				if m.Offset != moff {
+					continue
+				}
+
+				mType := btf.UnderlyingType(m.Type)
+				if mPtr, isPtr := btf.As[*btf.Pointer](mType); isPtr {
+					if _, isFuncProto := btf.As[*btf.FuncProto](mPtr.Target); isFuncProto {
+						p, ok := progs[sym.Name]
+						if !(ok && p.Type == StructOps) {
+							return fmt.Errorf("program %q not found or not StructOps", sym.Name)
+						}
+						p.AttachTo = userSt.Name + ":" + m.Name
+					}
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
 type libbpfElfSectionDef struct {
 	pattern     string
 	programType sys.ProgType