Override oomprof elf reader to delegate to pfelf

Author: gnurizen

interpreter/oomwatcher/elfreader.go

@@ -0,0 +1,61 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package oomwatcher // import "go.opentelemetry.io/ebpf-profiler/interpreter/oomwatcher"
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/parca-dev/oomprof/oomprof"
+	"go.opentelemetry.io/ebpf-profiler/libpf"
+	"go.opentelemetry.io/ebpf-profiler/libpf/pfelf"
+)
+
+// pfelfReader implements oomprof.ELFReader using libpf/pfelf.
+type pfelfReader struct{}
+
+// Open opens an ELF file using pfelf.
+func (r *pfelfReader) Open(path string) (oomprof.ELFFile, error) {
+	file, err := pfelf.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	return &pfelfFile{file: file}, nil
+}
+
+// pfelfFile implements oomprof.ELFFile using libpf/pfelf.File.
+type pfelfFile struct {
+	file *pfelf.File
+}
+
+// Close closes the ELF file.
+func (f *pfelfFile) Close() error {
+	return f.file.Close()
+}
+
+// GetBuildID returns the build ID of the ELF file.
+func (f *pfelfFile) GetBuildID() (string, error) {
+	return f.file.GetBuildID()
+}
+
+// GoVersion returns the Go version the binary was built with.
+func (f *pfelfFile) GoVersion() (string, error) {
+	return f.file.GoVersion()
+}
+
+// LookupSymbol looks up a symbol by name and returns its address.
+func (f *pfelfFile) LookupSymbol(name string) (oomprof.SymbolInfo, error) {
+	sym, err := f.file.LookupSymbol(libpf.SymbolName(name))
+	if err != nil {
+		if errors.Is(err, libpf.ErrSymbolNotFound) {
+			return oomprof.SymbolInfo{}, fmt.Errorf("symbol %s not found", name)
+		}
+		return oomprof.SymbolInfo{}, err
+	}
+
+	return oomprof.SymbolInfo{
+		Name:    string(sym.Name),
+		Address: uint64(sym.Address),
+	}, nil
+}

interpreter/oomwatcher/elfreader_test.go

@@ -0,0 +1,79 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package oomwatcher
+
+import (
+	"testing"
+
+	"github.com/parca-dev/oomprof/oomprof"
+)
+
+func TestPfelfReaderImplementsInterface(t *testing.T) {
+	// Verify that pfelfReader implements oomprof.ELFReader
+	var _ oomprof.ELFReader = &pfelfReader{}
+}
+
+func TestPfelfFileImplementsInterface(t *testing.T) {
+	// Verify that pfelfFile implements oomprof.ELFFile
+	var _ oomprof.ELFFile = &pfelfFile{}
+}
+
+func TestInit(t *testing.T) {
+	// Verify that the global ELF reader is set
+	reader := oomprof.GetELFReader()
+	if reader == nil {
+		t.Fatal("Expected global ELF reader to be set")
+	}
+
+	// Verify it's our implementation by checking the type
+	if _, ok := reader.(*pfelfReader); !ok {
+		t.Errorf("Expected global ELF reader to be *pfelfReader, got %T", reader)
+	}
+}
+
+func TestPfelfReaderOpenAndRead(t *testing.T) {
+	reader := &pfelfReader{}
+
+	// Try to open the Go binary itself (should be a Go binary)
+	file, err := reader.Open("/home/tpr/.gvm/gos/go1.25.1/bin/go")
+	if err != nil {
+		t.Skipf("Could not open Go binary for testing: %v", err)
+	}
+	defer file.Close()
+
+	// Test GetBuildID
+	buildID, err := file.GetBuildID()
+	if err != nil {
+		t.Logf("GetBuildID returned error (may be expected): %v", err)
+	} else {
+		t.Logf("Build ID: %s", buildID)
+		if buildID == "" {
+			t.Error("Expected non-empty build ID")
+		}
+	}
+
+	// Test GoVersion
+	goVersion, err := file.GoVersion()
+	if err != nil {
+		t.Fatalf("GoVersion failed: %v", err)
+	}
+	if goVersion == "" {
+		t.Error("Expected non-empty Go version")
+	}
+	t.Logf("Go version: %s", goVersion)
+
+	// Test LookupSymbol - try to find a common Go symbol
+	symInfo, err := file.LookupSymbol("runtime.main")
+	if err != nil {
+		t.Logf("Could not find runtime.main symbol: %v", err)
+	} else {
+		t.Logf("Found symbol runtime.main at address 0x%x", symInfo.Address)
+		if symInfo.Name != "runtime.main" {
+			t.Errorf("Expected symbol name 'runtime.main', got '%s'", symInfo.Name)
+		}
+		if symInfo.Address == 0 {
+			t.Error("Expected non-zero address for runtime.main")
+		}
+	}
+}

interpreter/oomwatcher/oomwatcher.go

@@ -14,6 +14,12 @@ import (
 	"go.opentelemetry.io/ebpf-profiler/remotememory"
 )
 
+func init() {
+	// Set the pfelf-based ELF reader as the default for oomprof.
+	// This provides optimized ELF file reading compared to debug/elf.
+	oomprof.SetELFReader(&pfelfReader{})
+}
+
 // oomWatcherData holds per-executable data for the OOM watcher observer.
 type oomWatcherData struct {
 	state *oomprof.State