Refactor dlopen tracking to use uprobe instead of USDT/polling (#164)

This commit refactors the dlopen tracking mechanism to use a more
efficient uprobe-based approach, eliminating the need for USDT probes
and the polling fallback mechanism.

Key changes:

* **rtld interpreter simplification**:
  - Store dlopen symbol address in Loader
  - Remove polling-based fallback mechanism (rtld_poller.go)
  - Simplify Loader to only detect dlopen symbol presence
  - Use direct uprobe attachment via AttachUprobe()

* **eBPF changes**:
  - Move uprobe_dlopen handler from usdt.ebpf.c to uprobe.ebpf.c
  - Remove usdt.ebpf.c (no longer needed)
  - Consolidate uprobe handlers in single file

* **Metrics updates**:
  - Rename DlopenUSDTHits to DlopenUprobeHits
  - Update metric descriptions to reflect uprobe usage

Benefits:
- Avoid the poller overhead and complexity
- More reliable dlopen detection (no dependency on USDT probe availability)
- Better performance (symbol lookup done once in Loader vs every Attach)

Author: gnurizen

interpreter/instancestubs.go

@@ -77,9 +77,7 @@ func (mockup *EbpfHandlerStubs) AttachUSDTProbes(libpf.PID, string, string, []pf
 	return nil, nil
 }
 
-func (mockup *EbpfHandlerStubs) TriggerProcessSync(libpf.PID) error {
-	return nil
-}
-
-func (mockup *EbpfHandlerStubs) SetProcessSyncTrigger(func(pid libpf.PID)) {
+func (mockup *EbpfHandlerStubs) AttachUprobe(
+	libpf.PID, string, uint64, string) (LinkCloser, error) {
+	return nil, nil
 }

interpreter/rtld/rtld.go

@@ -5,125 +5,71 @@ package rtld // import "go.opentelemetry.io/ebpf-profiler/interpreter/rtld"
 
 import (
 	"fmt"
-	"path"
-	"regexp"
 
 	log "github.com/sirupsen/logrus"
 	"go.opentelemetry.io/ebpf-profiler/interpreter"
 	"go.opentelemetry.io/ebpf-profiler/libpf"
-	"go.opentelemetry.io/ebpf-profiler/libpf/pfelf"
 	"go.opentelemetry.io/ebpf-profiler/remotememory"
 )
 
-// LdsoRegexp matches ld.so filenames across different distributions
-var LdsoRegexp = regexp.MustCompile(
-	`^ld(?:-linux)?(?:-x86-64|-aarch64)?\.so\.\d+$|` +
-		`^ld\.so\.\d+$|` +
-		`^ld-\d+\.\d+\.so$|` +
-		`^ld-musl-[^/]+\.so\.\d+$`)
-
 // data holds the Uprobe link to keep it in memory
 type data struct {
-	path      string
-	usePoller bool
-	probe     pfelf.USDTProbe
-	lc        interpreter.LinkCloser
+	path    string
+	address uint64
+	lc      interpreter.LinkCloser
 }
 
-// instance represents a per-PID instance of the rtld interpreter
+// instance represents a per-PID instance of the dlopen interpreter
 type instance struct {
 	interpreter.InstanceStubs
-	usePoller bool
-	lc        interpreter.LinkCloser
+	lc interpreter.LinkCloser
 }
 
-// Loader detects if the ELF file contains the rtld:map_complete USDT probe
+// Loader detects if the ELF file contains the dlopen symbol in its dynamic symbol table
 func Loader(ebpf interpreter.EbpfHandler, info *interpreter.LoaderInfo) (interpreter.Data, error) {
-	// Check if this is ld.so by examining just the basename
 	fileName := info.FileName()
-	baseName := path.Base(fileName)
-	if !LdsoRegexp.MatchString(baseName) {
-		return nil, nil
-	}
 
 	ef, err := info.GetELF()
 	if err != nil {
 		return nil, err
 	}
 
-	// Look for .note.stapsdt section which contains USDT probes
-	sec := ef.Section(".note.stapsdt")
-	if sec == nil {
-		log.Debugf("No .note.stapsdt section found in %s, will use poller fallback", fileName)
-		return &data{
-			path:      fileName,
-			usePoller: true,
-		}, nil
+	// Look for the dlopen symbol in the dynamic symbol table
+	sym, err := ef.LookupSymbol("dlopen")
+	if err != nil || sym == nil {
+		// No dlopen symbol found, this library doesn't support dynamic loading
+		return nil, nil
 	}
 
-	// Parse USDT probes from the section
-	probes, err := pfelf.ParseUSDTProbes(sec)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse USDT probes: %w", err)
-	}
-	// Look for rtld:map_complete probe
-	for _, probe := range probes {
-		if probe.Provider != "rtld" || probe.Name != "map_complete" {
-			continue
-		}
-		log.Debugf("Found rtld:map_complete USDT probe in %s at 0x%x",
-			fileName, probe.Location)
+	log.Debugf("Found dlopen symbol in %s at 0x%x", fileName, sym.Address)
 
-		return &data{
-			probe: probe,
-			path:  fileName,
-		}, nil
-	}
-
-	// No rtld:map_complete probe found, use poller fallback
-	log.Debugf("No rtld:map_complete probe found in %s, will use poller fallback", fileName)
 	return &data{
-		path:      fileName,
-		usePoller: true,
+		path:    fileName,
+		address: uint64(sym.Address),
 	}, nil
 }
 
-// Attach attaches the uprobe to the rtld:map_complete USDT probe or registers with poller
-func (d *data) Attach(ebpf interpreter.EbpfHandler, pid libpf.PID, _ libpf.Address,
+// Attach attaches the uprobe to the dlopen function
+func (d *data) Attach(ebpf interpreter.EbpfHandler, pid libpf.PID, bias libpf.Address,
 	_ remotememory.RemoteMemory) (interpreter.Instance, error) {
-	if d.usePoller {
-		// Register this PID with the global poller
-		// Create a trigger function that calls TriggerProcessSync on the ebpf handler
-		triggerFunc := func(triggerPID libpf.PID) {
-			if err := ebpf.TriggerProcessSync(triggerPID); err != nil {
-				log.Debugf("[rtld] TriggerProcessSync failed for PID %d: %v", triggerPID, err)
-			}
-		}
-		getPoller(triggerFunc).registerPID(pid)
-		log.Debugf("[rtld] Registered PID %d with poller for %s", pid, d.path)
-
-		return &instance{usePoller: true}, nil
-	} else {
-		prog := "usdt_rtld_map_complete"
-		lc, err := ebpf.AttachUSDTProbes(
-			pid, d.path, prog, []pfelf.USDTProbe{d.probe}, nil, nil, false)
-		if err != nil {
-			return nil, fmt.Errorf("failed to attach uprobe to rtld:map_complete usdt: %w", err)
-		}
-		log.Debugf("[rtld] Using USDT probe for PID %d on %s", pid, d.path)
-		d.lc = lc
-		return &instance{lc: lc}, nil
+	// Attach uprobe to dlopen using the address stored during Loader
+	lc, err := ebpf.AttachUprobe(pid, d.path, d.address, "uprobe_dlopen")
+	if err != nil {
+		return nil, fmt.Errorf("failed to attach uprobe to dlopen: %w", err)
 	}
+
+	log.Debugf("[dlopen] Attached uprobe to dlopen for PID %d on %s at 0x%x",
+		pid, d.path, d.address)
+
+	d.lc = lc
+	return &instance{lc: lc}, nil
 }
 
-// Detach removes the uprobe or deregisters from poller
+// Detach removes the uprobe
 func (i *instance) Detach(_ interpreter.EbpfHandler, pid libpf.PID) error {
-	log.Debugf("[rtld] Detach called for PID %d", pid)
-	if i.usePoller {
-		// Deregister this PID from the global poller
-		// Pass a nil trigger function since we're just deregistering
-		getPoller(nil).deregisterPID(pid)
-		log.Debugf("[rtld] Deregistered PID %d from poller", pid)
+	log.Debugf("[dlopen] Detach called for PID %d", pid)
+	if i.lc != nil {
+		return i.lc.Detach()
 	}
 	return nil
 }
@@ -132,9 +78,9 @@ func (i *instance) Detach(_ interpreter.EbpfHandler, pid libpf.PID) error {
 func (d *data) Unload(_ interpreter.EbpfHandler) {
 	if d.lc != nil {
 		if err := d.lc.Unload(); err != nil {
-			log.Errorf("[rtld] Failed to unload uprobe link: %v", err)
+			log.Errorf("[dlopen] Failed to unload uprobe link: %v", err)
 		}
 		d.lc = nil
 	}
-	log.Debugf("[rtld] Unloaded uprobe for %s", d.path)
+	log.Debugf("[dlopen] Unloaded uprobe for %s", d.path)
 }