[Dynamic Instrumentation] Fix stability issues

pkg/dynamicinstrumentation/diconfig/binary_inspection.go

@@ -23,12 +23,20 @@ import (
 // configEvent maps service names to info about the service and their configurations
 func inspectGoBinaries(configEvent ditypes.DIProcs) error {
 	var err error
+	var inspectedAtLeastOneBinary bool
 	for i := range configEvent {
 		err = AnalyzeBinary(configEvent[i])
 		if err != nil {
-			return fmt.Errorf("inspection of PID %d (path=%s) failed: %w", configEvent[i].PID, configEvent[i].BinaryPath, err)
+			log.Info("inspection of PID %d (path=%s) failed: %w", configEvent[i].PID, configEvent[i].BinaryPath, err)
+		} else {
+			inspectedAtLeastOneBinary = true
 		}
 	}
+
+	if !inspectedAtLeastOneBinary {
+		return fmt.Errorf("failed to inspect all tracked go binaries")
+	}
+
 	return nil
 }
 

pkg/dynamicinstrumentation/diconfig/config_manager.go

@@ -236,6 +236,12 @@ func (cm *RCConfigManager) readConfigs(r *ringbuf.Reader, procInfo *ditypes.Proc
 
 		// Check hash to see if the configuration changed
 		if configPath.Hash != probe.InstrumentationInfo.ConfigurationHash {
+			err := AnalyzeBinary(procInfo)
+			if err != nil {
+				log.Errorf("couldn't inspect binary: %v\n", err)
+				continue
+			}
+
 			probe.InstrumentationInfo.ConfigurationHash = configPath.Hash
 			applyConfigUpdate(procInfo, probe)
 		}
@@ -244,14 +250,9 @@ func (cm *RCConfigManager) readConfigs(r *ringbuf.Reader, procInfo *ditypes.Proc
 
 func applyConfigUpdate(procInfo *ditypes.ProcessInfo, probe *ditypes.Probe) {
 	log.Tracef("Applying config update: %v\n", probe)
-	err := AnalyzeBinary(procInfo)
-	if err != nil {
-		log.Errorf("couldn't inspect binary: %v\n", err)
-		return
-	}
 
 generateCompileAttach:
-	err = codegen.GenerateBPFParamsCode(procInfo, probe)
+	err := codegen.GenerateBPFParamsCode(procInfo, probe)
 	if err != nil {
 		log.Info("Couldn't generate BPF programs", err)
 		if !probe.InstrumentationInfo.AttemptedRebuild {

pkg/dynamicinstrumentation/diconfig/location_expression.go

@@ -166,6 +166,11 @@ func GenerateLocationExpression(limitsInfo *ditypes.InstrumentationInfo, param *
 					}
 					slicePointer := elementParam.ParameterPieces[0]
 					sliceLength := elementParam.ParameterPieces[1]
+
+					if slicePointer == nil || sliceLength == nil {
+						continue
+					}
+
 					sliceLength.LocationExpressions = append(sliceLength.LocationExpressions,
 						ditypes.PrintStatement("%s", "Reading the length of slice"),
 					)
@@ -188,6 +193,11 @@ func GenerateLocationExpression(limitsInfo *ditypes.InstrumentationInfo, param *
 					// Generate and collect the location expressions for collecting an individual
 					// element of this slice
 					sliceElementType := slicePointer.ParameterPieces[0]
+
+					if sliceElementType == nil {
+						continue
+					}
+
 					sliceIdentifier := randomLabel()
 					labelName := randomLabel()
 

pkg/dynamicinstrumentation/diconfig/mem_config_manager.go

@@ -72,9 +72,17 @@ func (cm *ReaderConfigManager) update() error {
 		for pid, proc := range cm.ConfigWriter.Processes {
 			// If a config exists relevant to this proc
 			if proc.ServiceName == serviceName {
-				procCopy := *proc
-				updatedState[pid] = &procCopy
-				updatedState[pid].ProbesByID = convert(serviceName, configsByID)
+				updatedState[pid] = &ditypes.ProcessInfo{
+					PID:                    proc.PID,
+					ServiceName:            proc.ServiceName,
+					RuntimeID:              proc.RuntimeID,
+					BinaryPath:             proc.BinaryPath,
+					TypeMap:                proc.TypeMap,
+					ConfigurationUprobe:    proc.ConfigurationUprobe,
+					InstrumentationUprobes: proc.InstrumentationUprobes,
+					InstrumentationObjects: proc.InstrumentationObjects,
+					ProbesByID:             convert(serviceName, configsByID),
+				}
 			}
 		}
 	}

pkg/dynamicinstrumentation/ditypes/config.go

@@ -14,6 +14,7 @@ import (
 	"io"
 	"strconv"
 	"strings"
+	"sync"
 
 	"github.com/DataDog/datadog-agent/pkg/util/log"
 
@@ -138,6 +139,7 @@ type ProcessInfo struct {
 	ProbesByID             ProbesByID
 	InstrumentationUprobes map[ProbeID]*link.Link
 	InstrumentationObjects map[ProbeID]*ebpf.Collection
+	mu                     sync.RWMutex
 }
 
 // SetupConfigUprobe sets the configuration probe for the process
@@ -172,12 +174,16 @@ func (pi *ProcessInfo) CloseConfigUprobe() error {
 // SetUprobeLink associates the uprobe link with the specified probe
 // in the tracked process
 func (pi *ProcessInfo) SetUprobeLink(probeID ProbeID, l *link.Link) {
+	pi.mu.Lock()
+	defer pi.mu.Unlock()
 	pi.InstrumentationUprobes[probeID] = l
 }
 
 // CloseUprobeLink closes the probe and deletes the link for the probe
 // in the tracked process
 func (pi *ProcessInfo) CloseUprobeLink(probeID ProbeID) error {
+	pi.mu.Lock()
+	defer pi.mu.Unlock()
 	if l, ok := pi.InstrumentationUprobes[probeID]; ok {
 		err := (*l).Close()
 		delete(pi.InstrumentationUprobes, probeID)