pfelf, interpreters, elfunwindinfo: refactor to not use mmap

instead read the section and program header data using io.ReaderAt

Author: fabled

interpreter/go/go.go

@@ -109,23 +109,19 @@ func (g *goInstance) Symbolize(frame *host.Frame, frames *libpf.Frames) error {
 	sfCounter := successfailurecounter.New(&g.successCount, &g.failCount)
 	defer sfCounter.DefaultToFailure()
 
-	sourceFile, lineNo, fn := g.d.pclntab.Symbolize(uintptr(frame.Lineno))
-	if fn == "" {
+	sourceFile, lineNo, fn := g.d.pclntab.Symbolize(uint64(frame.Lineno))
+	if fn == libpf.NullString {
 		return fmt.Errorf("failed to symbolize 0x%x", frame.Lineno)
 	}
 
 	frames.Append(&libpf.Frame{
 		Type: libpf.GoFrame,
 		//TODO: File: convert the frame.File (host.FileID) to libpf.FileID here
 		AddressOrLineno: frame.Lineno,
-		FunctionName:    libpf.Intern(fn),
-		SourceFile:      libpf.Intern(sourceFile),
+		FunctionName:    fn,
+		SourceFile:      sourceFile,
 		SourceLine:      libpf.SourceLineno(lineNo),
 	})
 	sfCounter.ReportSuccess()
 	return nil
 }
-
-func (g *goInstance) ReleaseResources() error {
-	return g.d.pclntab.SetDontNeed()
-}

interpreter/golabels/tls_amd64.go

@@ -40,8 +40,8 @@ func extractTLSGOffset(f *pfelf.File) (int32, error) {
 	}
 
 	sz := int(min(sym.Size, 128))
-	code, err := f.VirtualMemory(int64(sym.Address), sz, sz)
-	if err != nil {
+	code := make([]byte, sz)
+	if _, err = f.ReadAt(code, int64(sym.Address)); err != nil {
 		return 0, err
 	}
 

interpreter/golabels/tls_arm64.go

@@ -60,8 +60,9 @@ func extractTLSGOffset(f *pfelf.File) (int32, error) {
 			return 0, err
 		}
 	}
-	b, err := f.VirtualMemory(int64(sym.Address), 32, 32)
-	if err != nil {
+	sz := int(min(sym.Size, 32))
+	b := make([]byte, sz)
+	if _, err := f.ReadAt(b, int64(sym.Address)); err != nil {
 		return 0, err
 	}
 	for ; len(b) > 0; b = b[4:] {

interpreter/hotspot/data.go

@@ -4,7 +4,6 @@
 package hotspot // import "go.opentelemetry.io/ebpf-profiler/interpreter/hotspot"
 
 import (
-	"bytes"
 	"encoding/binary"
 	"errors"
 	"fmt"
@@ -18,6 +17,7 @@ import (
 
 	"go.opentelemetry.io/ebpf-profiler/interpreter"
 	"go.opentelemetry.io/ebpf-profiler/libpf"
+	"go.opentelemetry.io/ebpf-profiler/libpf/pfatbuf"
 	"go.opentelemetry.io/ebpf-profiler/libpf/pfelf"
 	"go.opentelemetry.io/ebpf-profiler/libpf/xsync"
 	"go.opentelemetry.io/ebpf-profiler/lpm"
@@ -396,48 +396,38 @@ func (d *hotspotData) Unload(_ interpreter.EbpfHandler) {
 //
 //nolint:lll
 func locateJvmciVMStructs(ef *pfelf.File) (libpf.Address, error) {
-	const maxDataReadSize = 1 * 1024 * 1024   // seen in practice: 192 KiB
-	const maxRodataReadSize = 4 * 1024 * 1024 // seen in practice: 753 KiB
-
-	rodataSec := ef.Section(".rodata")
-	if rodataSec == nil {
+	rodata := ef.Section(".rodata")
+	if rodata == nil {
 		return 0, errors.New("unable to find `.rodata` section")
 	}
+	cache := pfatbuf.Cache{}
+	cache.Init(rodata)
 
-	rodata, err := rodataSec.Data(maxRodataReadSize)
+	offs, err := cache.Search([]byte("Klass_vtable_start_offset"))
 	if err != nil {
-		return 0, err
-	}
-
-	offs := bytes.Index(rodata, []byte("Klass_vtable_start_offset"))
-	if offs == -1 {
 		return 0, errors.New("unable to find string for heuristic")
 	}
 
-	ptr := rodataSec.Addr + uint64(offs)
+	ptr := rodata.Addr + uint64(offs)
 	ptrEncoded := make([]byte, 8)
 	binary.LittleEndian.PutUint64(ptrEncoded, ptr)
 
-	dataSec := ef.Section(".data")
-	if dataSec == nil {
+	data := ef.Section(".data")
+	if data == nil {
 		return 0, errors.New("unable to find `.data` section")
 	}
+	cache.Init(data)
 
-	data, err := dataSec.Data(maxDataReadSize)
+	offs, err = cache.Search(ptrEncoded)
 	if err != nil {
-		return 0, err
-	}
-
-	offs = bytes.Index(data, ptrEncoded)
-	if offs == -1 {
 		return 0, errors.New("unable to find string pointer")
 	}
 
 	// 8 in the expression below is what we'd usually read from
 	// gHotSpotVMStructEntryFieldNameOffset. This value unfortunately lives in
 	// BSS, so we have no choice but to hard-code it. Fortunately enough this
 	// offset hasn't changed since at least JDK 9.
-	return libpf.Address(dataSec.Addr + uint64(offs) - 8), nil
+	return libpf.Address(data.Addr + uint64(offs) - 8), nil
 }
 
 // forEachItem walks the given struct reflection fields recursively, and calls the visitor

interpreter/instancestubs.go

@@ -33,7 +33,3 @@ func (is *InstanceStubs) Symbolize(*host.Frame, *libpf.Frames) error {
 func (is *InstanceStubs) GetAndResetMetrics() ([]metrics.Metric, error) {
 	return []metrics.Metric{}, nil
 }
-
-func (is *InstanceStubs) ReleaseResources() error {
-	return nil
-}

interpreter/multi.go

@@ -141,14 +141,3 @@ func (m *MultiInstance) GetAndResetMetrics() ([]metrics.Metric, error) {
 
 	return allMetrics, errors.Join(errs...)
 }
-
-func (m *MultiInstance) ReleaseResources() error {
-	var errs []error
-	for _, instance := range m.instances {
-		err := instance.ReleaseResources()
-		if err != nil {
-			errs = append(errs, err)
-		}
-	}
-	return errors.Join(errs...)
-}

interpreter/php/php.go

@@ -4,7 +4,6 @@
 package php // import "go.opentelemetry.io/ebpf-profiler/interpreter/php"
 
 import (
-	"bytes"
 	"debug/elf"
 	"errors"
 	"fmt"
@@ -18,8 +17,8 @@ import (
 
 	"go.opentelemetry.io/ebpf-profiler/interpreter"
 	"go.opentelemetry.io/ebpf-profiler/libpf"
+	"go.opentelemetry.io/ebpf-profiler/libpf/pfatbuf"
 	"go.opentelemetry.io/ebpf-profiler/libpf/pfelf"
-	"go.opentelemetry.io/ebpf-profiler/libpf/pfunsafe"
 	"go.opentelemetry.io/ebpf-profiler/remotememory"
 	"go.opentelemetry.io/ebpf-profiler/support"
 )
@@ -30,12 +29,6 @@ const (
 	ZEND_VM_KIND_HYBRID = (1 << 2)
 )
 
-const (
-	// maxPHPRODataSize is the maximum PHP RO Data segment size to scan
-	// (currently the largest seen is about 9M)
-	maxPHPRODataSize = 16 * 1024 * 1024
-)
-
 var (
 	// evalCodeFunctionName is a placeholder name to show that code has been evaluated
 	// using eval in PHP.
@@ -165,23 +158,21 @@ func determinePHPVersion(ef *pfelf.File) (uint, error) {
 		return 0, errors.New("no RO data")
 	}
 
+	cache := pfatbuf.Cache{}
 	needle := []byte("X-Powered-By: PHP/")
-	for _, segment := range ef.ROData {
-		rodata, err := segment.Data(maxPHPRODataSize)
+	for _, ph := range ef.ROData {
+		cache.Init(ph)
+
+		offs, err := cache.Search(needle)
 		if err != nil {
-			return 0, err
-		}
-		idx := bytes.Index(rodata, needle)
-		if idx < 0 {
 			continue
 		}
 
-		idx += len(needle)
-		zeroIdx := bytes.IndexByte(rodata[idx:], 0)
-		if zeroIdx < 0 {
+		verStr, err := cache.UnsafeStringAt(offs + int64(len(needle)))
+		if err != nil {
 			continue
 		}
-		version, err := versionExtract(pfunsafe.ToString(rodata[idx : idx+zeroIdx]))
+		version, err := versionExtract(verStr)
 		if err != nil {
 			continue
 		}

interpreter/types.go

@@ -154,7 +154,4 @@ type Instance interface {
 	// GetAndResetMetrics collects the metrics from the Instance and resets
 	// the counters to their initial value.
 	GetAndResetMetrics() ([]metrics.Metric, error)
-
-	// Release resources that are used to symbolize a stack.
-	ReleaseResources() error
 }