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

@@ -99,7 +99,7 @@ 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))
+	sourceFile, lineNo, fn := g.d.pclntab.Symbolize(uint64(frame.Lineno))
 	if fn == "" {
 		return fmt.Errorf("failed to symbolize 0x%x", frame.Lineno)
 	}
@@ -115,7 +115,3 @@ func (g *goInstance) Symbolize(frame *host.Frame, frames *libpf.Frames) error {
 	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/hotspot/data.go

@@ -4,7 +4,6 @@
 package hotspot // import "go.opentelemetry.io/ebpf-profiler/interpreter/hotspot"
 
 import (
-	"bytes"
 	"encoding/binary"
 	"errors"
 	"fmt"
@@ -399,45 +398,35 @@ 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")
 	}
 
-	rodata, err := rodataSec.Data(maxRodataReadSize)
+	offs, err := libpf.SearchReader(rodata, []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")
 	}
 
-	data, err := dataSec.Data(maxDataReadSize)
+	offs, err = libpf.SearchReader(data, 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"
@@ -19,7 +18,6 @@ import (
 	"go.opentelemetry.io/ebpf-profiler/interpreter"
 	"go.opentelemetry.io/ebpf-profiler/libpf"
 	"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"
 )
@@ -166,22 +164,18 @@ func determinePHPVersion(ef *pfelf.File) (uint, error) {
 	}
 
 	needle := []byte("X-Powered-By: PHP/")
-	for _, segment := range ef.ROData {
-		rodata, err := segment.Data(maxPHPRODataSize)
+	for _, ph := range ef.ROData {
+		offs, err := libpf.SearchReader(ph, 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 := libpf.ReadString(ph, 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
 }

libpf/io.go

@@ -0,0 +1,49 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package libpf // import "go.opentelemetry.io/ebpf-profiler/libpf"
+
+import (
+	"bytes"
+	"errors"
+	"io"
+)
+
+var errStringTooLong = errors.New("too long string")
+
+func ReadString(r io.ReaderAt, offset int64) (string, error) {
+	var data [4096]byte
+
+	// Read in chunks of 128 bytes
+	const chunkSize = 128
+	for i := 0; i < len(data) - chunkSize; i += chunkSize {
+		n, err := r.ReadAt(data[i:i+chunkSize], int64(i) + offset)
+		zeroIdx := bytes.IndexByte(data[i:i+n], 0)
+		if zeroIdx >= 0 {
+			return string(data[:i+zeroIdx]), nil
+		}
+		if err != nil {
+			return "", errStringTooLong
+		}
+	}
+	return "", io.EOF
+}
+
+func SearchReader(r io.ReaderAt, needle []byte) (int64, error) {
+	var buf[64*1024]byte
+
+	fileOffs := int64(0)
+	for {
+		n, err := r.ReadAt(buf[:], fileOffs)
+		// process 'n' bytes
+		bufOffs := bytes.Index(buf[:n], needle)
+		if bufOffs >= 0 {
+			return fileOffs + int64(bufOffs), nil
+		}
+		if n < len(needle) || err != nil {
+			return -1, err
+		}
+		fileOffs += int64(n - len(needle) + 1)
+	}
+	return -1, io.EOF
+}