pkg/proc: process spawned event

_fixtures/nongochild/child.bat

@@ -0,0 +1,2 @@
+@echo off
+echo Hello World

_fixtures/nongochild/child.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+echo "Hello World"

_fixtures/nongochild/main.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+)
+
+func main() {
+	file := "child.sh"
+	if runtime.GOOS == "windows" {
+		// This path is not actually exercised currently because prog_windows.go
+		// doesn't handle ErrBadBinaryInfo.
+		file = "child.bat"
+	}
+	file, err := filepath.Abs(file)
+	if err != nil {
+		panic(err)
+	}
+
+	output, err := exec.Command(file).Output()
+	if err != nil {
+		panic(err)
+	}
+	os.Stdout.Write(output)
+}

pkg/proc/native/proc_linux.go

@@ -518,7 +518,14 @@ func trapWaitInternal(procgrp *processGroup, pid int, options trapWaitOptions) (
 			cmdline, _ := dbp.initializeBasic()
 			tgt, err := procgrp.add(dbp, dbp.pid, dbp.memthread, findExecutable("", dbp.pid), proc.StopLaunched, cmdline)
 			if err != nil {
-				return nil, err
+				if errors.As(err, new(*proc.ErrBadBinaryInfo)) {
+					// If we are unable to load the binary info, log the error
+					// but don't return it. This allows the client to continue
+					// debugging the parent process.
+					logflags.DebuggerLogger().Warnf("Child target %d %q cannot be debugged: %v", pid, cmdline, err)
+				} else {
+					return nil, err
+				}
 			}
 			if halt {
 				return nil, nil

pkg/proc/native/proc_windows.go

@@ -404,6 +404,7 @@ func (procgrp *processGroup) waitForDebugEvent(flags waitForDebugEventFlags) (th
 				}
 				tgt, err := procgrp.add(dbp, dbp.pid, dbp.memthread, exe, proc.StopLaunched, getCmdLine(dbp.os.hProcess))
 				if err != nil {
+					// TODO: Handle proc.ErrBadBinaryInfo
 					return 0, err
 				}
 				if tgt == nil {

pkg/proc/proc_test.go

@@ -5180,6 +5180,10 @@ func TestFollowExec(t *testing.T) {
 		pids := map[int]int{}
 		ns := map[string]int{}
 
+		// Collect events
+		var events []*proc.Event
+		grp.SetEventsFn(func(e *proc.Event) { events = append(events, e) })
+
 		for {
 			t.Log("Continuing")
 			err := grp.Continue()
@@ -5218,6 +5222,15 @@ func TestFollowExec(t *testing.T) {
 				if finished {
 					t.Fatalf("breakpoint hit after the last one in a child process")
 				}
+
+				spawned := map[int]*proc.ProcessSpawnedEventDetails{}
+				for _, event := range events {
+					if event.Kind == proc.EventProcessSpawned {
+						details := event.ProcessSpawnedEventDetails
+						spawned[details.PID] = details
+					}
+				}
+
 				it := proc.ValidTargets{Group: grp}
 				for it.Next() {
 					tgt := it.Target
@@ -5239,6 +5252,10 @@ func TestFollowExec(t *testing.T) {
 					}
 					t.Logf("variable 'n' on target %d: %#v (%v)", tgt.Pid(), nvar, nvar.Value)
 					ns[constant.StringVal(nvar.Value)]++
+
+					if _, ok := spawned[tgt.Pid()]; !ok {
+						t.Errorf("Expected a process spawned event for target %d", tgt.Pid())
+					}
 				}
 			}
 		}
@@ -5266,6 +5283,39 @@ func TestFollowExec(t *testing.T) {
 	})
 }
 
+func TestFollowExecNonGo(t *testing.T) {
+	skipOn(t, "follow exec not implemented on freebsd", "freebsd")
+	skipOn(t, "follow exec not implemented on macOS", "darwin")
+	skipOn(t, "non-Go process handling not implemented on Windows", "windows")
+	withTestProcessArgs("nongochild/", t, "../../_fixtures/nongochild/", []string{}, 0, func(p *proc.Target, grp *proc.TargetGroup, fixture protest.Fixture) {
+		assertNoError(grp.FollowExec(true, ""), t, "FollowExec")
+
+		// Collect events
+		var events []*proc.Event
+		grp.SetEventsFn(func(e *proc.Event) { events = append(events, e) })
+
+		// Execute the process
+		for {
+			t.Log("Continuing")
+			err := grp.Continue()
+			if errors.As(err, &proc.ErrProcessExited{}) {
+				break
+			}
+		}
+
+		// Verify that a child was spawned
+		var spawned *proc.ProcessSpawnedEventDetails
+		for _, event := range events {
+			if event.Kind == proc.EventProcessSpawned {
+				spawned = event.ProcessSpawnedEventDetails
+			}
+		}
+		if spawned == nil {
+			t.Fatal("Did not log an event for the child")
+		}
+	})
+}
+
 func TestEscapeCheckUnreadable(t *testing.T) {
 	// A failure in escapeCheck to dereference a field should not cause
 	// infinite recursion. See issue #3310.

pkg/proc/target.go

@@ -99,6 +99,15 @@ func (pe ErrProcessExited) Error() string {
 	return fmt.Sprintf("Process %d has exited with status %d", pe.Pid, pe.Status)
 }
 
+// ErrBadBinaryInfo indicates that loading binary info for the process failed.
+type ErrBadBinaryInfo struct {
+	Err error
+}
+
+func (e *ErrBadBinaryInfo) Error() string {
+	return e.Err.Error()
+}
+
 // StopReason describes the reason why the target process is stopped.
 // A process could be stopped for multiple simultaneous reasons, in which
 // case only one will be reported.
@@ -169,11 +178,11 @@ func (grp *TargetGroup) newTarget(p ProcessInternal, pid int, currentThread Thre
 
 	err = p.BinInfo().LoadBinaryInfo(path, entryPoint, grp.cfg.DebugInfoDirs)
 	if err != nil {
-		return nil, err
+		return nil, &ErrBadBinaryInfo{Err: err}
 	}
 	for _, image := range p.BinInfo().Images {
 		if image.loadErr != nil {
-			return nil, image.loadErr
+			return nil, &ErrBadBinaryInfo{Err: image.loadErr}
 		}
 	}
 

pkg/proc/target_group.go

@@ -106,12 +106,40 @@ func Restart(grp, oldgrp *TargetGroup, discard func(*LogicalBreakpoint, error))
 func (grp *TargetGroup) addTarget(p ProcessInternal, pid int, currentThread Thread, path string, stopReason StopReason, cmdline string) (*Target, error) {
 	logger := logflags.DebuggerLogger()
 	if len(grp.targets) > 0 {
+		willFollow := true
 		if !grp.followExecEnabled {
 			logger.Debugf("Detaching from child target (follow-exec disabled) %d %q", pid, cmdline)
-			return nil, nil
+			willFollow = false
 		}
 		if grp.followExecRegex != nil && !grp.followExecRegex.MatchString(cmdline) {
 			logger.Debugf("Detaching from child target (follow-exec regex not matched) %d %q", pid, cmdline)
+			willFollow = false
+		}
+
+		// Notify listeners that a child process was spawned.
+		//
+		// We do this regardless of whether the process is debuggable and
+		// regardless of whether follow-exec is enabled; when run by an IDE in
+		// DAP mode, we want to give the IDE a chance to handle the spawned
+		// process.
+		//
+		// Defer the call so that - if the process _can_ be debugged - listeners
+		// are notified after the new target is set up.
+		if grp.Selected != nil {
+			if fn := grp.Selected.BinInfo().eventsFn; fn != nil {
+				defer fn(&Event{
+					Kind: EventProcessSpawned,
+					ProcessSpawnedEventDetails: &ProcessSpawnedEventDetails{
+						PID:        pid,
+						ThreadID:   currentThread.ThreadID(),
+						Cmdline:    cmdline,
+						WillFollow: willFollow,
+					},
+				})
+			}
+		}
+
+		if !willFollow {
 			return nil, nil
 		}
 	}
@@ -576,6 +604,7 @@ type Event struct {
 	Kind EventKind
 	*BinaryInfoDownloadEventDetails
 	*BreakpointMaterializedEventDetails
+	*ProcessSpawnedEventDetails
 }
 
 type EventKind uint8
@@ -585,6 +614,7 @@ const (
 	EventStopped
 	EventBinaryInfoDownload
 	EventBreakpointMaterialized
+	EventProcessSpawned
 )
 
 // BinaryInfoDownloadEventDetails describes the details of a BinaryInfoDownloadEvent
@@ -596,3 +626,11 @@ type BinaryInfoDownloadEventDetails struct {
 type BreakpointMaterializedEventDetails struct {
 	Breakpoint *LogicalBreakpoint
 }
+
+// ProcessSpawnedEventDetails describes the details of a ProcessSpawnedEvent
+type ProcessSpawnedEventDetails struct {
+	PID        int
+	ThreadID   int
+	Cmdline    string
+	WillFollow bool
+}

pkg/terminal/terminal.go

@@ -148,6 +148,8 @@ func New(client service.Client, conf *config.Config) *Term {
 				}
 
 				fmt.Fprintf(t.stdout, "Breakpoint %d materialized at %s:%d%s\n", bp.ID, file, bp.Line, extra)
+			case api.EventProcessSpawned:
+				fmt.Fprintf(t.stdout, "Spawned new process '%s' (%d)\n", event.Cmdline, event.ProcessSpawnedEventDetails.PID)
 			}
 		})
 	}

service/api/conversions.go

@@ -479,5 +479,14 @@ func ConvertEvent(event *proc.Event) *Event {
 		}
 	}
 
+	if event.ProcessSpawnedEventDetails != nil {
+		r.ProcessSpawnedEventDetails = &ProcessSpawnedEventDetails{
+			PID:        event.ProcessSpawnedEventDetails.PID,
+			ThreadID:   event.ProcessSpawnedEventDetails.ThreadID,
+			Cmdline:    event.ProcessSpawnedEventDetails.Cmdline,
+			WillFollow: event.ProcessSpawnedEventDetails.WillFollow,
+		}
+	}
+
 	return r
 }

service/api/types.go

@@ -694,6 +694,7 @@ type Event struct {
 	Kind EventKind
 	*BinaryInfoDownloadEventDetails
 	*BreakpointMaterializedEventDetails
+	*ProcessSpawnedEventDetails
 }
 
 type EventKind uint8
@@ -703,6 +704,7 @@ const (
 	EventStopped
 	EventBinaryInfoDownload
 	EventBreakpointMaterialized
+	EventProcessSpawned
 )
 
 // BinaryInfoDownloadEventDetails describes the details of a BinaryInfoDownloadEvent
@@ -714,3 +716,11 @@ type BinaryInfoDownloadEventDetails struct {
 type BreakpointMaterializedEventDetails struct {
 	Breakpoint *Breakpoint
 }
+
+// ProcessSpawnedEventDetails describes the details of a ProcessSpawnedEvent
+type ProcessSpawnedEventDetails struct {
+	PID        int
+	ThreadID   int
+	Cmdline    string
+	WillFollow bool
+}

service/dap/server.go

@@ -4102,6 +4102,15 @@ func (s *Session) convertDebuggerEvent(event *proc.Event) {
 				},
 			},
 		})
+	case proc.EventProcessSpawned:
+		s.send(&dap.ProcessEvent{
+			Event: *newEvent("process"),
+			Body: dap.ProcessEventBody{
+				Name:            event.Cmdline,
+				SystemProcessId: event.PID,
+				IsLocalProcess:  true,
+			},
+		})
 	}
 }