Send Ctrl+C to launched process before killing it on Windows

Author: tmat

sdk.slnx

@@ -50,9 +50,9 @@
     <Project Path="src/BuiltInTools/HotReloadAgent.Data/Microsoft.DotNet.HotReload.Agent.Data.shproj" />
     <Project Path="src/BuiltInTools/HotReloadAgent.PipeRpc/Microsoft.DotNet.HotReload.Agent.PipeRpc.Package.csproj" />
     <Project Path="src/BuiltInTools/HotReloadAgent.PipeRpc/Microsoft.DotNet.HotReload.Agent.PipeRpc.shproj" />
+    <Project Path="src/BuiltInTools/HotReloadAgent.WebAssembly.Browser/Microsoft.DotNet.HotReload.WebAssembly.Browser.csproj" />
     <Project Path="src/BuiltInTools/HotReloadAgent/Microsoft.DotNet.HotReload.Agent.Package.csproj" />
     <Project Path="src/BuiltInTools/HotReloadAgent/Microsoft.DotNet.HotReload.Agent.shproj" />
-    <Project Path="src/BuiltInTools/HotReloadAgent.WebAssembly.Browser/Microsoft.DotNet.HotReload.WebAssembly.Browser.csproj" />
   </Folder>
   <Folder Name="/src/Cli/">
     <Project Path="src/Cli/dotnet/dotnet.csproj" />

src/BuiltInTools/DotNetDeltaApplier/Microsoft.Extensions.DotNetDeltaApplier.csproj

@@ -25,6 +25,9 @@
   <ItemGroup Condition="'$(DotNetBuildSourceOnly)' == 'true' and '$(TargetFramework)' == 'net6.0'">
     <FrameworkReference Update="Microsoft.NETCore.App" TargetingPackVersion="6.0.0" />
   </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\dotnet-watch\Utilities\ProcessUtilities.cs" Link="ProcessUtilities.cs" />
+  </ItemGroup>
 
   <ItemGroup>
     <InternalsVisibleTo Include="Microsoft.Extensions.DotNetDeltaApplier.Tests" />

src/BuiltInTools/DotNetDeltaApplier/StartupHook.cs

@@ -4,6 +4,7 @@
 using System.Diagnostics;
 using System.IO.Pipes;
 using Microsoft.DotNet.HotReload;
+using Microsoft.DotNet.Watch;
 
 /// <summary>
 /// The runtime startup hook looks for top-level type named "StartupHook".
@@ -58,7 +59,7 @@ public static void Initialize()
             return;
         }
 
-        RegisterPosixSignalHandlers();
+        RegisterSignalHandlers();
 
         var agent = new HotReloadAgent();
         try
@@ -79,27 +80,34 @@ public static void Initialize()
         }
     }
 
-    private static void RegisterPosixSignalHandlers()
+    private static void RegisterSignalHandlers()
     {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            ProcessUtilities.EnableWindowsCtrlCHandling(Log);
+        }
+        else
+        {
 #if NET10_0_OR_GREATER
-        // Register a handler for SIGTERM to allow graceful shutdown of the application on Unix.
-        // See https://github.com/dotnet/docs/issues/46226.
+            // Register a handler for SIGTERM to allow graceful shutdown of the application on Unix.
+            // See https://github.com/dotnet/docs/issues/46226.
 
-        // Note: registered handlers are executed in reverse order of their registration.
-        // Since the startup hook is executed before any code of the application, it is the first handler registered and thus the last to run.
-
-        s_signalRegistration = PosixSignalRegistration.Create(PosixSignal.SIGTERM, context =>
-        {
-            Log($"SIGTERM received. Cancel={context.Cancel}");
+            // Note: registered handlers are executed in reverse order of their registration.
+            // Since the startup hook is executed before any code of the application, it is the first handler registered and thus the last to run.
 
-            if (!context.Cancel)
+            s_signalRegistration = PosixSignalRegistration.Create(PosixSignal.SIGTERM, context =>
             {
-                Environment.Exit(0);
-            }
-        });
+                Log($"SIGTERM received. Cancel={context.Cancel}");
 
-        Log("Posix signal handlers registered.");
+                if (!context.Cancel)
+                {
+                    Environment.Exit(0);
+                }
+            });
+
+            Log("Posix signal handlers registered.");
 #endif
+        }
     }
 
     private static async ValueTask InitializeAsync(NamedPipeClientStream pipeClient, HotReloadAgent agent, CancellationToken cancellationToken)

src/BuiltInTools/dotnet-watch/CommandLine/EnvironmentOptions.cs

@@ -22,6 +22,11 @@ internal enum TestFlags
         /// This allows tests to trigger key based events.
         /// </summary>
         ReadKeyFromStdin = 1 << 3,
+
+        /// <summary>
+        /// Set if dotnet-watch should re-enable Ctrl+C handling on Windows.
+        /// </summary>
+        EnableWindowsCtrlCHandling = 1 << 4,
     }
 
     internal sealed record EnvironmentOptions(

src/BuiltInTools/dotnet-watch/HotReload/CompilationHandler.cs

@@ -130,7 +130,7 @@ public async ValueTask StartSessionAsync(CancellationToken cancellationToken)
             };
 
             var launchResult = new ProcessLaunchResult();
-            var runningProcess = _processRunner.RunAsync(processSpec, processReporter, isUserApplication: true, launchResult, processTerminationSource.Token);
+            var runningProcess = _processRunner.RunAsync(processSpec, processReporter, launchResult, processTerminationSource.Token);
             if (launchResult.ProcessId == null)
             {
                 // error already reported

src/BuiltInTools/dotnet-watch/HotReload/HotReloadDotNetWatcher.cs

@@ -796,6 +796,7 @@ await FileWatcher.WaitForFileChangeAsync(
             {
                 Executable = _context.EnvironmentOptions.MuxerPath,
                 WorkingDirectory = Path.GetDirectoryName(projectPath)!,
+                IsUserApplication = false,
                 OnOutput = line =>
                 {
                     lock (buildOutput)
@@ -804,12 +805,12 @@ await FileWatcher.WaitForFileChangeAsync(
                     }
                 },
                 // pass user-specified build arguments last to override defaults:
-                Arguments = ["build", projectPath, "-consoleLoggerParameters:NoSummary;Verbosity=minimal", .. binLogArguments, .. buildArguments]
+                Arguments = ["build", projectPath, "-consoleLoggerParameters:NoSummary;Verbosity=minimal", .. binLogArguments, .. buildArguments],
             };
 
             _context.Reporter.Output($"Building {projectPath} ...");
 
-            var exitCode = await _context.ProcessRunner.RunAsync(processSpec, _context.Reporter, isUserApplication: false, launchResult: null, cancellationToken);
+            var exitCode = await _context.ProcessRunner.RunAsync(processSpec, _context.Reporter, launchResult: null, cancellationToken);
             return (exitCode == 0, buildOutput.ToImmutableArray(), projectPath);
         }
 

src/BuiltInTools/dotnet-watch/Process/ProcessRunner.cs

@@ -10,20 +10,27 @@ internal sealed class ProcessRunner(
         TimeSpan processCleanupTimeout,
         CancellationToken shutdownCancellationToken)
     {
-        private const int SIGKILL = 9;
-        private const int SIGTERM = 15;
-
         private sealed class ProcessState
         {
             public int ProcessId;
             public bool HasExited;
         }
 
+        // For testing purposes only, lock on access.
+        private static readonly HashSet<int> s_runningApplicationProcesses = [];
+
+        public static IReadOnlyCollection<int> GetRunningApplicationProcesses()
+        {
+            lock (s_runningApplicationProcesses)
+            {
+                return [.. s_runningApplicationProcesses];
+            }
+        }
+
         /// <summary>
         /// Launches a process.
         /// </summary>
-        /// <param name="isUserApplication">True if the process is a user application, false if it is a helper process (e.g. msbuild).</param>
-        public async Task<int> RunAsync(ProcessSpec processSpec, IReporter reporter, bool isUserApplication, ProcessLaunchResult? launchResult, CancellationToken processTerminationToken)
+        public async Task<int> RunAsync(ProcessSpec processSpec, IReporter reporter, ProcessLaunchResult? launchResult, CancellationToken processTerminationToken)
         {
             var state = new ProcessState();
             var stopwatch = new Stopwatch();
@@ -49,6 +56,14 @@ public async Task<int> RunAsync(ProcessSpec processSpec, IReporter reporter, boo
 
                 state.ProcessId = process.Id;
 
+                if (processSpec.IsUserApplication)
+                {
+                    lock (s_runningApplicationProcesses)
+                    {
+                        s_runningApplicationProcesses.Add(state.ProcessId);
+                    }
+                }
+
                 if (onOutput != null)
                 {
                     process.BeginOutputReadLine();
@@ -90,12 +105,12 @@ public async Task<int> RunAsync(ProcessSpec processSpec, IReporter reporter, boo
                     // Either Ctrl+C was pressed or the process is being restarted.
 
                     // Non-cancellable to not leave orphaned processes around blocking resources:
-                    await TerminateProcessAsync(process, state, reporter, CancellationToken.None);
+                    await TerminateProcessAsync(process, processSpec, state, reporter, CancellationToken.None);
                 }
             }
             catch (Exception e)
             {
-                if (isUserApplication)
+                if (processSpec.IsUserApplication)
                 {
                     reporter.Error($"Application failed: {e.Message}");
                 }
@@ -104,6 +119,14 @@ public async Task<int> RunAsync(ProcessSpec processSpec, IReporter reporter, boo
             {
                 stopwatch.Stop();
 
+                if (processSpec.IsUserApplication)
+                {
+                    lock (s_runningApplicationProcesses)
+                    {
+                        s_runningApplicationProcesses.Remove(state.ProcessId);
+                    }
+                }
+
                 state.HasExited = true;
 
                 try
@@ -117,7 +140,7 @@ public async Task<int> RunAsync(ProcessSpec processSpec, IReporter reporter, boo
 
                 reporter.Verbose($"Process id {process.Id} ran for {stopwatch.ElapsedMilliseconds}ms and exited with exit code {exitCode}.");
 
-                if (isUserApplication)
+                if (processSpec.IsUserApplication)
                 {
                     if (exitCode == 0)
                     {
@@ -157,6 +180,11 @@ private static Process CreateProcess(ProcessSpec processSpec, Action<OutputLine>
                 }
             };
 
+            if (processSpec.IsUserApplication && RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                process.StartInfo.CreateNewProcessGroup = true;
+            }
+
             if (processSpec.EscapedArguments is not null)
             {
                 process.StartInfo.Arguments = processSpec.EscapedArguments;
@@ -210,28 +238,27 @@ private static Process CreateProcess(ProcessSpec processSpec, Action<OutputLine>
             return process;
         }
 
-        private async ValueTask TerminateProcessAsync(Process process, ProcessState state, IReporter reporter, CancellationToken cancellationToken)
+        private async ValueTask TerminateProcessAsync(Process process, ProcessSpec processSpec, ProcessState state, IReporter reporter, CancellationToken cancellationToken)
         {
             if (!shutdownCancellationToken.IsCancellationRequested)
             {
-                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            }
+
+            //{
+                var forceOnly = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && !processSpec.IsUserApplication;
+
+                // Ctrl+C hasn't been sent.
+                TerminateProcess(process, state, reporter, forceOnly);
+
+                if (forceOnly)
                 {
-                    // Ctrl+C hasn't been sent, force termination.
-                    // We don't have means to terminate gracefully on Windows (https://github.com/dotnet/runtime/issues/109432)
-                    TerminateProcess(process, state, reporter, force: true);
                     _ = await WaitForExitAsync(process, state, timeout: null, reporter, cancellationToken);
-
                     return;
                 }
-                else
-                {
-                    // Ctrl+C hasn't been sent, send SIGTERM now:
-                    TerminateProcess(process, state, reporter, force: false);
-                }
-            }
+            //}
 
             // Ctlr+C/SIGTERM has been sent, wait for the process to exit gracefully.
-            if (processCleanupTimeout.Milliseconds == 0 ||
+            if (processCleanupTimeout.TotalMilliseconds == 0 ||
                 !await WaitForExitAsync(process, state, processCleanupTimeout, reporter, cancellationToken))
             {
                 // Force termination if the process is still running after the timeout.
@@ -327,55 +354,28 @@ private static void TerminateProcess(Process process, ProcessState state, IRepor
 
         private static void TerminateWindowsProcess(Process process, ProcessState state, IReporter reporter, bool force)
         {
-            // Needs API: https://github.com/dotnet/runtime/issues/109432
-            // Code below does not work because the process creation needs CREATE_NEW_PROCESS_GROUP flag.
+            var processId = state.ProcessId;
 
-            reporter.Verbose($"Terminating process {state.ProcessId}.");
+            reporter.Verbose($"Terminating process {processId} ({(force ? "Kill" : "Ctrl+C")}).");
 
             if (force)
             {
                 process.Kill();
             }
-#if TODO
             else
             {
-                const uint CTRL_C_EVENT = 0;
-
-                [DllImport("kernel32.dll", SetLastError = true)]
-                static extern bool GenerateConsoleCtrlEvent(uint dwCtrlEvent, uint dwProcessGroupId);
-
-                [DllImport("kernel32.dll", SetLastError = true)]
-                static extern bool AttachConsole(uint dwProcessId);
-
-                [DllImport("kernel32.dll", SetLastError = true)]
-                static extern bool FreeConsole();
-
-                if (AttachConsole((uint)state.ProcessId) &&
-                    GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0) &&
-                    FreeConsole())
-                {
-                    return;
-                }
-
-                var error = Marshal.GetLastPInvokeError();
-                reporter.Verbose($"Failed to send Ctrl+C to process {state.ProcessId}: {Marshal.GetPInvokeErrorMessage(error)} (code {error})");
+                ProcessUtilities.SendWindowsCtrlCEvent(processId, m => reporter.Verbose(m));
             }
-#endif
         }
 
         private static void TerminateUnixProcess(ProcessState state, IReporter reporter, bool force)
         {
-            [DllImport("libc", SetLastError = true, EntryPoint = "kill")]
-            static extern int sys_kill(int pid, int sig);
-
             reporter.Verbose($"Terminating process {state.ProcessId} ({(force ? "SIGKILL" : "SIGTERM")}).");
 
-            var result = sys_kill(state.ProcessId, force ? SIGKILL : SIGTERM);
-            if (result != 0)
-            {
-                var error = Marshal.GetLastPInvokeError();
-                reporter.Verbose($"Error while sending SIGTERM to process {state.ProcessId}: {Marshal.GetPInvokeErrorMessage(error)} (code {error}).");
-            }
+            ProcessUtilities.SendPosixSignal(
+                state.ProcessId,
+                signal: force ? ProcessUtilities.SIGKILL : ProcessUtilities.SIGTERM,
+                log: m => reporter.Verbose(m));
         }
     }
 }

src/BuiltInTools/dotnet-watch/Process/ProcessSpec.cs

@@ -15,6 +15,11 @@ internal sealed class ProcessSpec
         public ProcessExitAction? OnExit { get; set; }
         public CancellationToken CancelOutputCapture { get; set; }
 
+        /// <summary>
+        /// True if the process is a user application, false if it is a helper process (e.g. dotnet build).</param>
+        /// </summary>
+        public bool IsUserApplication { get; set; }
+
         public string? ShortDisplayName()
             => Path.GetFileNameWithoutExtension(Executable);
 

src/BuiltInTools/dotnet-watch/Process/ProjectLauncher.cs

@@ -47,8 +47,9 @@ public EnvironmentOptions EnvironmentOptions
         var processSpec = new ProcessSpec
         {
             Executable = EnvironmentOptions.MuxerPath,
+            IsUserApplication = true,
             WorkingDirectory = projectOptions.WorkingDirectory,
-            OnOutput = onOutput
+            OnOutput = onOutput,
         };
 
         var environmentBuilder = EnvironmentVariablesBuilder.FromCurrentEnvironment();

src/BuiltInTools/dotnet-watch/Program.cs

@@ -76,6 +76,12 @@ public static async Task<int> Main(string[] args)
             if (environmentOptions.TestFlags != TestFlags.None)
             {
                 reporter.Verbose($"Test flags: {environmentOptions.TestFlags}");
+
+                if (environmentOptions.TestFlags.HasFlag(TestFlags.EnableWindowsCtrlCHandling) &&
+                    RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                {
+                    ProcessUtilities.EnableWindowsCtrlCHandling(m => reporter.Verbose($"Test: {m}"));
+                }
             }
 
             if (!TryFindProject(workingDirectory, options, reporter, out var projectPath))