[EBPF] gpu: use inode and file size to index symbol files (#33937)

Author: gjulianm

pkg/gpu/context.go

@@ -20,6 +20,7 @@ import (
 	workloadmeta "github.com/DataDog/datadog-agent/comp/core/workloadmeta/def"
 	"github.com/DataDog/datadog-agent/pkg/errors"
 	"github.com/DataDog/datadog-agent/pkg/gpu/cuda"
+	"github.com/DataDog/datadog-agent/pkg/security/utils"
 	"github.com/DataDog/datadog-agent/pkg/util/ktime"
 	"github.com/DataDog/datadog-agent/pkg/util/log"
 )
@@ -41,7 +42,7 @@ type systemContext struct {
 	smVersionSet map[uint32]struct{}
 
 	// cudaSymbols maps each executable file path to its Fatbin file data
-	cudaSymbols map[string]*symbolsEntry
+	cudaSymbols map[symbolFileIdentifier]*symbolsEntry
 
 	// pidMaps maps each process ID to its memory maps
 	pidMaps map[int][]*procfs.ProcMap
@@ -77,6 +78,14 @@ type systemContext struct {
 	fatbinTelemetry *fatbinTelemetry
 }
 
+// symbolFileIdentifier holds the inode and file size of a symbol file, which we use to avoid
+// parsing the same file multiple times when it has different paths (e.g., symlinks in /proc/PID/root)
+// We add fileSize to the identifier to mitigate possible issues with inode reuse.
+type symbolFileIdentifier struct {
+	inode    int
+	fileSize int64
+}
+
 // contextTelemetry holds telemetry elements for the context
 type contextTelemetry struct {
 	symbolCacheSize telemetry.Gauge
@@ -106,7 +115,7 @@ func getSystemContext(nvmlLib nvml.Interface, procRoot string, wmeta workloadmet
 	ctx := &systemContext{
 		deviceSmVersions:          make(map[int]int),
 		smVersionSet:              make(map[uint32]struct{}),
-		cudaSymbols:               make(map[string]*symbolsEntry),
+		cudaSymbols:               make(map[symbolFileIdentifier]*symbolsEntry),
 		pidMaps:                   make(map[int][]*procfs.ProcMap),
 		nvmlLib:                   nvmlLib,
 		procRoot:                  procRoot,
@@ -186,8 +195,23 @@ func (ctx *systemContext) fillDeviceInfo() error {
 	return nil
 }
 
+func buildSymbolFileIdentifier(path string) (symbolFileIdentifier, error) {
+	stat, err := utils.UnixStat(path)
+	if err != nil {
+		return symbolFileIdentifier{}, fmt.Errorf("error getting file info: %w", err)
+	}
+
+	return symbolFileIdentifier{inode: int(stat.Ino), fileSize: stat.Size}, nil
+}
+
 func (ctx *systemContext) getCudaSymbols(path string) (*symbolsEntry, error) {
-	if data, ok := ctx.cudaSymbols[path]; ok {
+	fileIdent, err := buildSymbolFileIdentifier(path)
+	if err != nil {
+		// an error means we cannot access the file, so returning makes sense as we will fail later anyways
+		return nil, fmt.Errorf("error building symbol file identifier: %w", err)
+	}
+
+	if data, ok := ctx.cudaSymbols[fileIdent]; ok {
 		data.updateLastUsedTime()
 		return data, nil
 	}
@@ -210,7 +234,7 @@ func (ctx *systemContext) getCudaSymbols(path string) (*symbolsEntry, error) {
 
 	wrapper := &symbolsEntry{Symbols: data}
 	wrapper.updateLastUsedTime()
-	ctx.cudaSymbols[path] = wrapper
+	ctx.cudaSymbols[fileIdent] = wrapper
 
 	ctx.telemetry.symbolCacheSize.Set(float64(len(ctx.cudaSymbols)))
 

pkg/gpu/context_test.go

@@ -8,6 +8,7 @@
 package gpu
 
 import (
+	"os"
 	"strconv"
 	"strings"
 	"testing"
@@ -204,3 +205,50 @@ func TestGetCurrentActiveGpuDevice(t *testing.T) {
 		})
 	}
 }
+
+func TestBuildSymbolFileIdentifier(t *testing.T) {
+	// Create a file, then a symlink to it
+	// and check that the identifier is the same
+	// for both files.
+	dir := t.TempDir()
+	filePath := dir + "/file"
+	copyPath := dir + "/copy"
+	differentPath := dir + "/different"
+	symlinkPath := dir + "/symlink"
+
+	data := []byte("hello")
+	// create the original file
+	err := os.WriteFile(filePath, data, 0644)
+	require.NoError(t, err)
+
+	// create a symlink to the original file, which should have the same identifier
+	err = os.Symlink(filePath, symlinkPath)
+	require.NoError(t, err)
+
+	// a copy is a different inode, so it should have a different identifier
+	// even with the same size
+	err = os.WriteFile(copyPath, data, 0644)
+	require.NoError(t, err)
+
+	// a different file with different content should have a different identifier
+	// as it's different content and different inode
+	err = os.WriteFile(differentPath, []byte("different"), 0644)
+	require.NoError(t, err)
+
+	origIdentifier, err := buildSymbolFileIdentifier(filePath)
+	require.NoError(t, err)
+
+	symlinkIdentifier, err := buildSymbolFileIdentifier(symlinkPath)
+	require.NoError(t, err)
+
+	copyIdentifier, err := buildSymbolFileIdentifier(copyPath)
+	require.NoError(t, err)
+
+	differentIdentifier, err := buildSymbolFileIdentifier(differentPath)
+	require.NoError(t, err)
+
+	require.Equal(t, origIdentifier, symlinkIdentifier)
+	require.NotEqual(t, origIdentifier, copyIdentifier)
+	require.NotEqual(t, origIdentifier, differentIdentifier)
+	require.NotEqual(t, copyIdentifier, differentIdentifier)
+}

pkg/gpu/stream_test.go

@@ -350,7 +350,10 @@ func TestKernelLaunchesIncludeEnrichedKernelData(t *testing.T) {
 		ConstantMem: constantMem,
 	})
 
-	sysCtx.cudaSymbols[procBinPath] = &symbolsEntry{
+	procBinIdent, err := buildSymbolFileIdentifier(procBinPath)
+	require.NoError(t, err)
+
+	sysCtx.cudaSymbols[procBinIdent] = &symbolsEntry{
 		Symbols: &cuda.Symbols{
 			SymbolTable: map[uint64]string{kernAddress: kernName},
 			Fatbin:      fatbin,