Implement SafeProcessHandle.Kill and Signal

src/libraries/Common/src/Interop/Unix/System.Native/Interop.Kill.cs

@@ -1,21 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
 using System.Runtime.InteropServices;
 
 internal static partial class Interop
 {
  internal static partial class Sys
  {
- internal enum Signals : int
- {
- None = 0,
- SIGKILL = 9,
- SIGSTOP = 19
- }
-
  [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_Kill", SetLastError = true)]
- internal static partial int Kill(int pid, Signals signal);
+ internal static partial int Kill(int pid, int signal);
  }
 }

src/libraries/Common/src/Interop/Unix/System.Native/Interop.PosixSignal.cs

@@ -24,5 +24,9 @@ internal static partial class Sys
  [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetPlatformSignalNumber")]
  [SuppressGCTransition]
  internal static partial int GetPlatformSignalNumber(PosixSignal signal);
+
+ [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetPlatformSIGSTOP")]
+ [SuppressGCTransition]
+ internal static partial int GetPlatformSIGSTOP();
  }
 }

src/libraries/System.Diagnostics.Process/ref/System.Diagnostics.Process.cs

@@ -15,6 +15,14 @@ public SafeProcessHandle(System.IntPtr existingHandle, bool ownsHandle) : base (
  [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
  [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
  [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
+ public void Kill() { }
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+ [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
+ public bool Signal(System.Runtime.InteropServices.PosixSignal signal) { throw null; }
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+ [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
  public static Microsoft.Win32.SafeHandles.SafeProcessHandle Start(System.Diagnostics.ProcessStartInfo startInfo) { throw null; }
  }
 }

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.Unix.cs

@@ -59,6 +59,36 @@ protected override bool ReleaseHandle()
  // On Unix, we don't use process descriptors yet, so we can't get PID.
  private static int GetProcessIdCore() => throw new PlatformNotSupportedException();
 
+ private bool SignalCore(PosixSignal signal)
+ {
+ if (ProcessUtils.PlatformDoesNotSupportProcessStartAndKill)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ int signalNumber = Interop.Sys.GetPlatformSignalNumber(signal);
+ if (signalNumber == 0)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ int killResult = Interop.Sys.Kill(ProcessId, signalNumber);
+ if (killResult != 0)
+ {
+ Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
+
+ // Return false if the process has already exited (or never existed).
+ if (errorInfo.Error == Interop.Error.ESRCH)
+ {
+ return false;
+ }
+
+ throw new Win32Exception(errorInfo.RawErrno); // same exception as on Windows
+ }
+
+ return true;
+ }
+
  private delegate SafeProcessHandle StartWithShellExecuteDelegate(ProcessStartInfo startInfo, SafeFileHandle? stdinHandle, SafeFileHandle? stdoutHandle, SafeFileHandle? stderrHandle, out ProcessWaitState.Holder? waitStateHolder);
  private static StartWithShellExecuteDelegate? s_startWithShellExecute;
 

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.Windows.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Security;
@@ -330,5 +331,31 @@ Interop.Shell32.SE_ERR_DDEBUSY or
  }
 
  private int GetProcessIdCore() => Interop.Kernel32.GetProcessId(this);
+
+ private bool SignalCore(PosixSignal signal)
+ {
+ // On Windows, only SIGKILL is supported, mapped to TerminateProcess.
+ if (signal != PosixSignal.SIGKILL)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ if (!Interop.Kernel32.TerminateProcess(this, -1))
+ {
+ int errorCode = Marshal.GetLastWin32Error();
+
+ // Return false if the process has already exited.
+ if (errorCode == Interop.Errors.ERROR_ACCESS_DENIED &&
+ Interop.Kernel32.GetExitCodeProcess(this, out int exitCode) &&
+ exitCode != Interop.Kernel32.HandleOptions.STILL_ACTIVE)
+ {
+ return false;
+ }
+
+ throw new Win32Exception(errorCode);
+ }
+
+ return true;
+ }
  }
 }

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.cs

@@ -11,9 +11,11 @@
 ===========================================================*/
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.Serialization;
 using System.Runtime.Versioning;
+using System.Runtime.InteropServices;
 
 namespace Microsoft.Win32.SafeHandles
 {
@@ -123,6 +125,48 @@ public static SafeProcessHandle Start(ProcessStartInfo startInfo)
  return StartCore(startInfo, childInputHandle, childOutputHandle, childErrorHandle);
  }
 
+ /// <summary>
+ /// Sends a request to the OS to terminate the process.
+ /// </summary>
+ /// <remarks>
+ /// This method does not throw if the process has already exited.
+ /// On Windows, the handle must have <c>PROCESS_TERMINATE</c> access.
+ /// </remarks>
+ /// <exception cref="InvalidOperationException">The handle is invalid.</exception>
+ /// <exception cref="Win32Exception">The process could not be terminated.</exception>
+ [UnsupportedOSPlatform("ios")]
+ [UnsupportedOSPlatform("tvos")]
+ [SupportedOSPlatform("maccatalyst")]
+ public void Kill()
+ {
+ Validate();
+ SignalCore(PosixSignal.SIGKILL);
+ }
+
+ /// <summary>
+ /// Sends a signal to the process.
+ /// </summary>
+ /// <param name="signal">The signal to send.</param>
+ /// <returns>
+ /// <see langword="true"/> if the signal was sent successfully;
+ /// <see langword="false"/> if the process has already exited (or never existed) and the signal was not delivered.
+ /// </returns>
+ /// <remarks>
+ /// On Windows, only <see cref="PosixSignal.SIGKILL"/> is supported and is mapped to <see cref="Kill"/>.
+ /// On Windows, the handle must have <c>PROCESS_TERMINATE</c> access.
+ /// </remarks>
+ /// <exception cref="InvalidOperationException">The handle is invalid.</exception>
+ /// <exception cref="PlatformNotSupportedException">The specified signal is not supported on this platform.</exception>
+ /// <exception cref="Win32Exception">The signal could not be sent.</exception>
+ [UnsupportedOSPlatform("ios")]
+ [UnsupportedOSPlatform("tvos")]
+ [SupportedOSPlatform("maccatalyst")]
+ public bool Signal(PosixSignal signal)
+ {
+ Validate();
+ return SignalCore(signal);
+ }
+
  private void Validate()
  {
  if (IsInvalid)

src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj

@@ -263,6 +263,8 @@
  Link="Common\Interop\Unix\Interop.InitializeTerminalAndSignalHandling.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Kill.cs"
  Link="Common\Interop\Unix\Interop.Kill.cs" />
+ <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.PosixSignal.cs"
+ Link="Common\Interop\Unix\Interop.PosixSignal.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.ReadLink.cs"
  Link="Common\Interop\Unix\Interop.ReadLink.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.RegisterForSigChld.cs"

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs

@@ -69,7 +69,7 @@ public void Kill()
  return;
  }
 
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGKILL);
+ int killResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSignalNumber(PosixSignal.SIGKILL));
  if (killResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();
@@ -105,7 +105,7 @@ private void KillTree(ref List<Exception>? exceptions)
 
  // Stop the process, so it won't start additional children.
  // This is best effort: kill can return before the process is stopped.
- int stopResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGSTOP);
+ int stopResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSIGSTOP());
  if (stopResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();
@@ -119,7 +119,7 @@ private void KillTree(ref List<Exception>? exceptions)
 
  List<Process> children = GetChildProcesses();
 
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGKILL);
+ int killResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSignalNumber(PosixSignal.SIGKILL));
  if (killResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Windows.cs

@@ -93,20 +93,7 @@ public void Kill()
  if (handle.IsInvalid)
  return;
 
- if (!Interop.Kernel32.TerminateProcess(handle, -1))
- {
- // Capture the exception
- var exception = new Win32Exception();
-
- // Don't throw if the process has exited.
- if (exception.NativeErrorCode == Interop.Errors.ERROR_ACCESS_DENIED &&
- Interop.Kernel32.GetExitCodeProcess(handle, out int localExitCode) && localExitCode != Interop.Kernel32.HandleOptions.STILL_ACTIVE)
- {
- return;
- }
-
- throw exception;
- }
+ handle.Kill();
  }
  }
 

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Unix.cs

@@ -27,7 +27,7 @@ public static bool IsProcessRunning(int processId)
  {
  // kill with signal==0 means to not actually send a signal.
  // If we get back 0, the process is still alive.
- int output = Interop.Sys.Kill(processId, Interop.Sys.Signals.None);
+ int output = Interop.Sys.Kill(processId, 0);
  // If kill set errno=EPERM, assume querying process is alive.
  return 0 == output || (-1 == output && Interop.Error.EPERM == Interop.Sys.GetLastError());
  }

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessWaitState.Unix.cs

@@ -351,7 +351,7 @@ private void CheckForNonChildExit()
  bool exited;
  // We won't be able to get an exit code, but we'll at least be able to determine if the process is
  // still running.
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.None); // None means don't send a signal
+ int killResult = Interop.Sys.Kill(_processId, 0); // 0 means don't send a signal, used to check if process is still alive
  if (killResult == 0)
  {
  // Process is still running. This could also be a defunct process that has completed

src/libraries/System.Diagnostics.Process/tests/Interop.cs

@@ -73,6 +73,9 @@ public struct SID_AND_ATTRIBUTES
  }
 
 
+ [DllImport("kernel32.dll", SetLastError = true)]
+ internal static extern SafeProcessHandle OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
+
  [DllImport("kernel32.dll", SetLastError = true)]
  [return: MarshalAs(UnmanagedType.Bool)]
  public static extern bool GenerateConsoleCtrlEvent(uint dwCtrlEvent, uint dwProcessGroupId);

src/libraries/System.Diagnostics.Process/tests/ProcessTests.Unix.cs

@@ -909,18 +909,12 @@ public async Task Kill_ExitedNonChildProcess_DoesNotThrow(bool killTree)
  using (Process nonChildProcess = CreateNonChildProcess())
  {
  // Kill the process.
- int rv = kill(nonChildProcess.Id, SIGKILL);
- Assert.Equal(0, rv);
+ Assert.True(nonChildProcess.SafeHandle.Signal(PosixSignal.SIGKILL));
 
  // Wait until the process is reaped.
- while (rv == 0)
+ while (!nonChildProcess.HasExited)
  {
- rv = kill(nonChildProcess.Id, 0);
- if (rv == 0)
- {
- // process still exists, wait some time.
- await Task.Delay(100);
- }
+ await Task.Delay(100);
 
  DateTime now = DateTime.UtcNow;
  if (start.Ticks + (Helpers.PassingTestTimeoutMilliseconds * 10_000) <= now.Ticks)
@@ -1024,11 +1018,6 @@ private static unsafe HashSet<uint> GetGroups()
  [DllImport("libc")]
  private static extern unsafe int setgroups(int length, uint* groups);
 
- private const int SIGKILL = 9;
-
- [DllImport("libc", SetLastError = true)]
- private static extern int kill(int pid, int sig);
-
  [DllImport("libc", SetLastError = true)]
  private static extern int open(string pathname, int flags);
 
@@ -1062,14 +1051,7 @@ private static string StartAndReadToEnd(string filename, string[] arguments)
  }
  }
 
- private static void SendSignal(PosixSignal signal, int processId)
- {
- int result = kill(processId, Interop.Sys.GetPlatformSignalNumber(signal));
- if (result != 0)
- {
- throw new Win32Exception(Marshal.GetLastWin32Error(), $"Failed to send signal {signal} to process {processId}");
- }
- }
+ private static void SendSignal(PosixSignal signal, Process process) => Assert.True(process.SafeHandle.Signal(signal));
 
  private static unsafe void ReEnableCtrlCHandlerIfNeeded(PosixSignal signal) { }
 
@@ -1115,7 +1097,7 @@ public void ChildProcess_WithParentSignalHandler_CanReceiveSignals()
  AssertRemoteProcessStandardOutputLine(childHandle, ChildReadyMessage, WaitInMS);
 
  // Send SIGCONT to the child process
-SendSignal(PosixSignal.SIGCONT, childHandle.Process.Id);
+Assert.True(childHandle.Process.SafeHandle.Signal(PosixSignal.SIGCONT));
 
  Assert.True(childHandle.Process.WaitForExit(WaitInMS));
  Assert.Equal(RemotelyInvokable.SuccessExitCode, childHandle.Process.ExitCode);

src/libraries/System.Diagnostics.Process/tests/ProcessTests.Windows.cs

@@ -80,7 +80,7 @@ private string WriteScriptFile(string directory, string name, int returnValue)
  return filename;
  }
 
- private static void SendSignal(PosixSignal signal, int processId)
+ private static void SendSignal(PosixSignal signal, Process process)
  {
  uint dwCtrlEvent = signal switch
  {
@@ -89,7 +89,7 @@ private static void SendSignal(PosixSignal signal, int processId)
  _ => throw new ArgumentOutOfRangeException(nameof(signal))
  };
 
- if (!Interop.GenerateConsoleCtrlEvent(dwCtrlEvent, (uint)processId))
+ if (!Interop.GenerateConsoleCtrlEvent(dwCtrlEvent, (uint)process.Id))
  {
  int error = Marshal.GetLastWin32Error();
  if (error == Interop.Errors.ERROR_INVALID_FUNCTION && PlatformDetection.IsInContainer)

src/libraries/System.Diagnostics.Process/tests/ProcessTests.cs

@@ -170,7 +170,7 @@ public void TestCreateNewProcessGroup_HandlerReceivesExpectedSignal(PosixSignal
 
  try
  {
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
 
  Assert.True(remoteHandle.Process.WaitForExit(WaitInMS));
  Assert.Equal(0, remoteHandle.Process.ExitCode);
@@ -243,7 +243,7 @@ public void SignalHandler_CanDisposeInHandler(PosixSignal signal)
  {
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalRegistrationCreatedMessage, WaitInMS);
 
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
 
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalHandlerStartedMessage, WaitInMS);
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalHandlerDisposedMessage, WaitInMS);
@@ -253,11 +253,11 @@ public void SignalHandler_CanDisposeInHandler(PosixSignal signal)
  if (PlatformDetection.IsMonoRuntime && signal == PosixSignal.SIGQUIT && !PlatformDetection.IsWindows)
  {
  // Terminate process using SIGTERM instead.
- SendSignal(PosixSignal.SIGTERM, remoteHandle.Process.Id);
+ SendSignal(PosixSignal.SIGTERM, remoteHandle.Process);
  }
  else
  {
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
  }
 
  Assert.True(remoteHandle.Process.WaitForExit(WaitInMS));

src/libraries/Common/src/Interop/Unix/System.Native/Interop.Kill.cs

@@ -1,21 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
 using System.Runtime.InteropServices;
 
 internal static partial class Interop
 {
  internal static partial class Sys
  {
- internal enum Signals : int
- {
- None = 0,
- SIGKILL = 9,
- SIGSTOP = 19
- }
-
  [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_Kill", SetLastError = true)]
- internal static partial int Kill(int pid, Signals signal);
+ internal static partial int Kill(int pid, int signal);
  }
 }

src/libraries/Common/src/Interop/Unix/System.Native/Interop.PosixSignal.cs

@@ -24,5 +24,9 @@ internal static partial class Sys
  [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetPlatformSignalNumber")]
  [SuppressGCTransition]
  internal static partial int GetPlatformSignalNumber(PosixSignal signal);
+
+ [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetPlatformSIGSTOP")]
+ [SuppressGCTransition]
+ internal static partial int GetPlatformSIGSTOP();
  }
 }

src/libraries/System.Diagnostics.Process/ref/System.Diagnostics.Process.cs

@@ -15,6 +15,14 @@ public SafeProcessHandle(System.IntPtr existingHandle, bool ownsHandle) : base (
  [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
  [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
  [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
+ public void Kill() { }
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+ [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
+ public bool Signal(System.Runtime.InteropServices.PosixSignal signal) { throw null; }
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+ [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
  public static Microsoft.Win32.SafeHandles.SafeProcessHandle Start(System.Diagnostics.ProcessStartInfo startInfo) { throw null; }
  }
 }

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.Unix.cs

@@ -59,6 +59,36 @@ protected override bool ReleaseHandle()
  // On Unix, we don't use process descriptors yet, so we can't get PID.
  private static int GetProcessIdCore() => throw new PlatformNotSupportedException();
 
+ private bool SignalCore(PosixSignal signal)
+ {
+ if (ProcessUtils.PlatformDoesNotSupportProcessStartAndKill)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ int signalNumber = Interop.Sys.GetPlatformSignalNumber(signal);
+ if (signalNumber == 0)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ int killResult = Interop.Sys.Kill(ProcessId, signalNumber);
+ if (killResult != 0)
+ {
+ Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
+
+ // Return false if the process has already exited (or never existed).
+ if (errorInfo.Error == Interop.Error.ESRCH)
+ {
+ return false;
+ }
+
+ throw new Win32Exception(errorInfo.RawErrno); // same exception as on Windows
+ }
+
+ return true;
+ }
+
  private delegate SafeProcessHandle StartWithShellExecuteDelegate(ProcessStartInfo startInfo, SafeFileHandle? stdinHandle, SafeFileHandle? stdoutHandle, SafeFileHandle? stderrHandle, out ProcessWaitState.Holder? waitStateHolder);
  private static StartWithShellExecuteDelegate? s_startWithShellExecute;
 

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.Windows.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Security;
@@ -330,5 +331,31 @@ Interop.Shell32.SE_ERR_DDEBUSY or
  }
 
  private int GetProcessIdCore() => Interop.Kernel32.GetProcessId(this);
+
+ private bool SignalCore(PosixSignal signal)
+ {
+ // On Windows, only SIGKILL is supported, mapped to TerminateProcess.
+ if (signal != PosixSignal.SIGKILL)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ if (!Interop.Kernel32.TerminateProcess(this, -1))
+ {
+ int errorCode = Marshal.GetLastWin32Error();
+
+ // Return false if the process has already exited.
+ if (errorCode == Interop.Errors.ERROR_ACCESS_DENIED &&
+ Interop.Kernel32.GetExitCodeProcess(this, out int exitCode) &&
+ exitCode != Interop.Kernel32.HandleOptions.STILL_ACTIVE)
+ {
+ return false;
+ }
+
+ throw new Win32Exception(errorCode);
+ }
+
+ return true;
+ }
  }
 }

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.cs

@@ -11,9 +11,11 @@
 ===========================================================*/
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.Serialization;
 using System.Runtime.Versioning;
+using System.Runtime.InteropServices;
 
 namespace Microsoft.Win32.SafeHandles
 {
@@ -123,6 +125,48 @@ public static SafeProcessHandle Start(ProcessStartInfo startInfo)
  return StartCore(startInfo, childInputHandle, childOutputHandle, childErrorHandle);
  }
 
+ /// <summary>
+ /// Sends a request to the OS to terminate the process.
+ /// </summary>
+ /// <remarks>
+ /// This method does not throw if the process has already exited.
+ /// On Windows, the handle must have <c>PROCESS_TERMINATE</c> access.
+ /// </remarks>
+ /// <exception cref="InvalidOperationException">The handle is invalid.</exception>
+ /// <exception cref="Win32Exception">The process could not be terminated.</exception>
+ [UnsupportedOSPlatform("ios")]
+ [UnsupportedOSPlatform("tvos")]
+ [SupportedOSPlatform("maccatalyst")]
+ public void Kill()
+ {
+ Validate();
+ SignalCore(PosixSignal.SIGKILL);
+ }
+
+ /// <summary>
+ /// Sends a signal to the process.
+ /// </summary>
+ /// <param name="signal">The signal to send.</param>
+ /// <returns>
+ /// <see langword="true"/> if the signal was sent successfully;
+ /// <see langword="false"/> if the process has already exited (or never existed) and the signal was not delivered.
+ /// </returns>
+ /// <remarks>
+ /// On Windows, only <see cref="PosixSignal.SIGKILL"/> is supported and is mapped to <see cref="Kill"/>.
+ /// On Windows, the handle must have <c>PROCESS_TERMINATE</c> access.
+ /// </remarks>
+ /// <exception cref="InvalidOperationException">The handle is invalid.</exception>
+ /// <exception cref="PlatformNotSupportedException">The specified signal is not supported on this platform.</exception>
+ /// <exception cref="Win32Exception">The signal could not be sent.</exception>
+ [UnsupportedOSPlatform("ios")]
+ [UnsupportedOSPlatform("tvos")]
+ [SupportedOSPlatform("maccatalyst")]
+ public bool Signal(PosixSignal signal)
+ {
+ Validate();
+ return SignalCore(signal);
+ }
+
  private void Validate()
  {
  if (IsInvalid)

src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj

@@ -263,6 +263,8 @@
  Link="Common\Interop\Unix\Interop.InitializeTerminalAndSignalHandling.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Kill.cs"
  Link="Common\Interop\Unix\Interop.Kill.cs" />
+ <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.PosixSignal.cs"
+ Link="Common\Interop\Unix\Interop.PosixSignal.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.ReadLink.cs"
  Link="Common\Interop\Unix\Interop.ReadLink.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.RegisterForSigChld.cs"

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs

@@ -69,7 +69,7 @@ public void Kill()
  return;
  }
 
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGKILL);
+ int killResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSignalNumber(PosixSignal.SIGKILL));
  if (killResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();
@@ -105,7 +105,7 @@ private void KillTree(ref List<Exception>? exceptions)
 
  // Stop the process, so it won't start additional children.
  // This is best effort: kill can return before the process is stopped.
- int stopResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGSTOP);
+ int stopResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSIGSTOP());
  if (stopResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();
@@ -119,7 +119,7 @@ private void KillTree(ref List<Exception>? exceptions)
 
  List<Process> children = GetChildProcesses();
 
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGKILL);
+ int killResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSignalNumber(PosixSignal.SIGKILL));
  if (killResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Windows.cs

@@ -93,20 +93,7 @@ public void Kill()
  if (handle.IsInvalid)
  return;
 
- if (!Interop.Kernel32.TerminateProcess(handle, -1))
- {
- // Capture the exception
- var exception = new Win32Exception();
-
- // Don't throw if the process has exited.
- if (exception.NativeErrorCode == Interop.Errors.ERROR_ACCESS_DENIED &&
- Interop.Kernel32.GetExitCodeProcess(handle, out int localExitCode) && localExitCode != Interop.Kernel32.HandleOptions.STILL_ACTIVE)
- {
- return;
- }
-
- throw exception;
- }
+ handle.Kill();
  }
  }
 

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Unix.cs

@@ -27,7 +27,7 @@ public static bool IsProcessRunning(int processId)
  {
  // kill with signal==0 means to not actually send a signal.
  // If we get back 0, the process is still alive.
- int output = Interop.Sys.Kill(processId, Interop.Sys.Signals.None);
+ int output = Interop.Sys.Kill(processId, 0);
  // If kill set errno=EPERM, assume querying process is alive.
  return 0 == output || (-1 == output && Interop.Error.EPERM == Interop.Sys.GetLastError());
  }

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessWaitState.Unix.cs

@@ -351,7 +351,7 @@ private void CheckForNonChildExit()
  bool exited;
  // We won't be able to get an exit code, but we'll at least be able to determine if the process is
  // still running.
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.None); // None means don't send a signal
+ int killResult = Interop.Sys.Kill(_processId, 0); // 0 means don't send a signal, used to check if process is still alive
  if (killResult == 0)
  {
  // Process is still running. This could also be a defunct process that has completed

src/libraries/System.Diagnostics.Process/tests/Interop.cs

@@ -73,6 +73,9 @@ public struct SID_AND_ATTRIBUTES
  }
 
 
+ [DllImport("kernel32.dll", SetLastError = true)]
+ internal static extern SafeProcessHandle OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
+
  [DllImport("kernel32.dll", SetLastError = true)]
  [return: MarshalAs(UnmanagedType.Bool)]
  public static extern bool GenerateConsoleCtrlEvent(uint dwCtrlEvent, uint dwProcessGroupId);

src/libraries/System.Diagnostics.Process/tests/ProcessTests.Unix.cs

@@ -909,18 +909,12 @@ public async Task Kill_ExitedNonChildProcess_DoesNotThrow(bool killTree)
  using (Process nonChildProcess = CreateNonChildProcess())
  {
  // Kill the process.
- int rv = kill(nonChildProcess.Id, SIGKILL);
- Assert.Equal(0, rv);
+ Assert.True(nonChildProcess.SafeHandle.Signal(PosixSignal.SIGKILL));
 
  // Wait until the process is reaped.
- while (rv == 0)
+ while (!nonChildProcess.HasExited)
  {
- rv = kill(nonChildProcess.Id, 0);
- if (rv == 0)
- {
- // process still exists, wait some time.
- await Task.Delay(100);
- }
+ await Task.Delay(100);
 
  DateTime now = DateTime.UtcNow;
  if (start.Ticks + (Helpers.PassingTestTimeoutMilliseconds * 10_000) <= now.Ticks)
@@ -1024,11 +1018,6 @@ private static unsafe HashSet<uint> GetGroups()
  [DllImport("libc")]
  private static extern unsafe int setgroups(int length, uint* groups);
 
- private const int SIGKILL = 9;
-
- [DllImport("libc", SetLastError = true)]
- private static extern int kill(int pid, int sig);
-
  [DllImport("libc", SetLastError = true)]
  private static extern int open(string pathname, int flags);
 
@@ -1062,14 +1051,7 @@ private static string StartAndReadToEnd(string filename, string[] arguments)
  }
  }
 
- private static void SendSignal(PosixSignal signal, int processId)
- {
- int result = kill(processId, Interop.Sys.GetPlatformSignalNumber(signal));
- if (result != 0)
- {
- throw new Win32Exception(Marshal.GetLastWin32Error(), $"Failed to send signal {signal} to process {processId}");
- }
- }
+ private static void SendSignal(PosixSignal signal, Process process) => Assert.True(process.SafeHandle.Signal(signal));
 
  private static unsafe void ReEnableCtrlCHandlerIfNeeded(PosixSignal signal) { }
 
@@ -1115,7 +1097,7 @@ public void ChildProcess_WithParentSignalHandler_CanReceiveSignals()
  AssertRemoteProcessStandardOutputLine(childHandle, ChildReadyMessage, WaitInMS);
 
  // Send SIGCONT to the child process
-SendSignal(PosixSignal.SIGCONT, childHandle.Process.Id);
+Assert.True(childHandle.Process.SafeHandle.Signal(PosixSignal.SIGCONT));
 
  Assert.True(childHandle.Process.WaitForExit(WaitInMS));
  Assert.Equal(RemotelyInvokable.SuccessExitCode, childHandle.Process.ExitCode);

src/libraries/System.Diagnostics.Process/tests/ProcessTests.Windows.cs

@@ -80,7 +80,7 @@ private string WriteScriptFile(string directory, string name, int returnValue)
  return filename;
  }
 
- private static void SendSignal(PosixSignal signal, int processId)
+ private static void SendSignal(PosixSignal signal, Process process)
  {
  uint dwCtrlEvent = signal switch
  {
@@ -89,7 +89,7 @@ private static void SendSignal(PosixSignal signal, int processId)
  _ => throw new ArgumentOutOfRangeException(nameof(signal))
  };
 
- if (!Interop.GenerateConsoleCtrlEvent(dwCtrlEvent, (uint)processId))
+ if (!Interop.GenerateConsoleCtrlEvent(dwCtrlEvent, (uint)process.Id))
  {
  int error = Marshal.GetLastWin32Error();
  if (error == Interop.Errors.ERROR_INVALID_FUNCTION && PlatformDetection.IsInContainer)

src/libraries/System.Diagnostics.Process/tests/ProcessTests.cs

@@ -170,7 +170,7 @@ public void TestCreateNewProcessGroup_HandlerReceivesExpectedSignal(PosixSignal
 
  try
  {
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
 
  Assert.True(remoteHandle.Process.WaitForExit(WaitInMS));
  Assert.Equal(0, remoteHandle.Process.ExitCode);
@@ -243,7 +243,7 @@ public void SignalHandler_CanDisposeInHandler(PosixSignal signal)
  {
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalRegistrationCreatedMessage, WaitInMS);
 
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
 
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalHandlerStartedMessage, WaitInMS);
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalHandlerDisposedMessage, WaitInMS);
@@ -253,11 +253,11 @@ public void SignalHandler_CanDisposeInHandler(PosixSignal signal)
  if (PlatformDetection.IsMonoRuntime && signal == PosixSignal.SIGQUIT && !PlatformDetection.IsWindows)
  {
  // Terminate process using SIGTERM instead.
- SendSignal(PosixSignal.SIGTERM, remoteHandle.Process.Id);
+ SendSignal(PosixSignal.SIGTERM, remoteHandle.Process);
  }
  else
  {
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
  }
 
  Assert.True(remoteHandle.Process.WaitForExit(WaitInMS));

src/libraries/Common/src/Interop/Unix/System.Native/Interop.Kill.cs

@@ -1,21 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
 using System.Runtime.InteropServices;
 
 internal static partial class Interop
 {
  internal static partial class Sys
  {
- internal enum Signals : int
- {
- None = 0,
- SIGKILL = 9,
- SIGSTOP = 19
- }
-
  [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_Kill", SetLastError = true)]
- internal static partial int Kill(int pid, Signals signal);
+ internal static partial int Kill(int pid, int signal);
  }
 }

src/libraries/Common/src/Interop/Unix/System.Native/Interop.PosixSignal.cs

@@ -24,5 +24,9 @@ internal static partial class Sys
  [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetPlatformSignalNumber")]
  [SuppressGCTransition]
  internal static partial int GetPlatformSignalNumber(PosixSignal signal);
+
+ [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetPlatformSIGSTOP")]
+ [SuppressGCTransition]
+ internal static partial int GetPlatformSIGSTOP();
  }
 }

src/libraries/System.Diagnostics.Process/ref/System.Diagnostics.Process.cs

@@ -15,6 +15,14 @@ public SafeProcessHandle(System.IntPtr existingHandle, bool ownsHandle) : base (
  [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
  [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
  [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
+ public void Kill() { }
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+ [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
+ public bool Signal(System.Runtime.InteropServices.PosixSignal signal) { throw null; }
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+ [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
  public static Microsoft.Win32.SafeHandles.SafeProcessHandle Start(System.Diagnostics.ProcessStartInfo startInfo) { throw null; }
  }
 }

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.Unix.cs

@@ -59,6 +59,36 @@ protected override bool ReleaseHandle()
  // On Unix, we don't use process descriptors yet, so we can't get PID.
  private static int GetProcessIdCore() => throw new PlatformNotSupportedException();
 
+ private bool SignalCore(PosixSignal signal)
+ {
+ if (ProcessUtils.PlatformDoesNotSupportProcessStartAndKill)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ int signalNumber = Interop.Sys.GetPlatformSignalNumber(signal);
+ if (signalNumber == 0)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ int killResult = Interop.Sys.Kill(ProcessId, signalNumber);
+ if (killResult != 0)
+ {
+ Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
+
+ // Return false if the process has already exited (or never existed).
+ if (errorInfo.Error == Interop.Error.ESRCH)
+ {
+ return false;
+ }
+
+ throw new Win32Exception(errorInfo.RawErrno); // same exception as on Windows
+ }
+
+ return true;
+ }
+
  private delegate SafeProcessHandle StartWithShellExecuteDelegate(ProcessStartInfo startInfo, SafeFileHandle? stdinHandle, SafeFileHandle? stdoutHandle, SafeFileHandle? stderrHandle, out ProcessWaitState.Holder? waitStateHolder);
  private static StartWithShellExecuteDelegate? s_startWithShellExecute;
 

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.Windows.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Security;
@@ -330,5 +331,31 @@ Interop.Shell32.SE_ERR_DDEBUSY or
  }
 
  private int GetProcessIdCore() => Interop.Kernel32.GetProcessId(this);
+
+ private bool SignalCore(PosixSignal signal)
+ {
+ // On Windows, only SIGKILL is supported, mapped to TerminateProcess.
+ if (signal != PosixSignal.SIGKILL)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ if (!Interop.Kernel32.TerminateProcess(this, -1))
+ {
+ int errorCode = Marshal.GetLastWin32Error();
+
+ // Return false if the process has already exited.
+ if (errorCode == Interop.Errors.ERROR_ACCESS_DENIED &&
+ Interop.Kernel32.GetExitCodeProcess(this, out int exitCode) &&
+ exitCode != Interop.Kernel32.HandleOptions.STILL_ACTIVE)
+ {
+ return false;
+ }
+
+ throw new Win32Exception(errorCode);
+ }
+
+ return true;
+ }
  }
 }

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.cs

@@ -11,9 +11,11 @@
 ===========================================================*/
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.Serialization;
 using System.Runtime.Versioning;
+using System.Runtime.InteropServices;
 
 namespace Microsoft.Win32.SafeHandles
 {
@@ -123,6 +125,48 @@ public static SafeProcessHandle Start(ProcessStartInfo startInfo)
  return StartCore(startInfo, childInputHandle, childOutputHandle, childErrorHandle);
  }
 
+ /// <summary>
+ /// Sends a request to the OS to terminate the process.
+ /// </summary>
+ /// <remarks>
+ /// This method does not throw if the process has already exited.
+ /// On Windows, the handle must have <c>PROCESS_TERMINATE</c> access.
+ /// </remarks>
+ /// <exception cref="InvalidOperationException">The handle is invalid.</exception>
+ /// <exception cref="Win32Exception">The process could not be terminated.</exception>
+ [UnsupportedOSPlatform("ios")]
+ [UnsupportedOSPlatform("tvos")]
+ [SupportedOSPlatform("maccatalyst")]
+ public void Kill()
+ {
+ Validate();
+ SignalCore(PosixSignal.SIGKILL);
+ }
+
+ /// <summary>
+ /// Sends a signal to the process.
+ /// </summary>
+ /// <param name="signal">The signal to send.</param>
+ /// <returns>
+ /// <see langword="true"/> if the signal was sent successfully;
+ /// <see langword="false"/> if the process has already exited (or never existed) and the signal was not delivered.
+ /// </returns>
+ /// <remarks>
+ /// On Windows, only <see cref="PosixSignal.SIGKILL"/> is supported and is mapped to <see cref="Kill"/>.
+ /// On Windows, the handle must have <c>PROCESS_TERMINATE</c> access.
+ /// </remarks>
+ /// <exception cref="InvalidOperationException">The handle is invalid.</exception>
+ /// <exception cref="PlatformNotSupportedException">The specified signal is not supported on this platform.</exception>
+ /// <exception cref="Win32Exception">The signal could not be sent.</exception>
+ [UnsupportedOSPlatform("ios")]
+ [UnsupportedOSPlatform("tvos")]
+ [SupportedOSPlatform("maccatalyst")]
+ public bool Signal(PosixSignal signal)
+ {
+ Validate();
+ return SignalCore(signal);
+ }
+
  private void Validate()
  {
  if (IsInvalid)

src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj

@@ -263,6 +263,8 @@
  Link="Common\Interop\Unix\Interop.InitializeTerminalAndSignalHandling.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Kill.cs"
  Link="Common\Interop\Unix\Interop.Kill.cs" />
+ <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.PosixSignal.cs"
+ Link="Common\Interop\Unix\Interop.PosixSignal.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.ReadLink.cs"
  Link="Common\Interop\Unix\Interop.ReadLink.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.RegisterForSigChld.cs"

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs

@@ -69,7 +69,7 @@ public void Kill()
  return;
  }
 
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGKILL);
+ int killResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSignalNumber(PosixSignal.SIGKILL));
  if (killResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();
@@ -105,7 +105,7 @@ private void KillTree(ref List<Exception>? exceptions)
 
  // Stop the process, so it won't start additional children.
  // This is best effort: kill can return before the process is stopped.
- int stopResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGSTOP);
+ int stopResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSIGSTOP());
  if (stopResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();
@@ -119,7 +119,7 @@ private void KillTree(ref List<Exception>? exceptions)
 
  List<Process> children = GetChildProcesses();
 
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGKILL);
+ int killResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSignalNumber(PosixSignal.SIGKILL));
  if (killResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Windows.cs

@@ -93,20 +93,7 @@ public void Kill()
  if (handle.IsInvalid)
  return;
 
- if (!Interop.Kernel32.TerminateProcess(handle, -1))
- {
- // Capture the exception
- var exception = new Win32Exception();
-
- // Don't throw if the process has exited.
- if (exception.NativeErrorCode == Interop.Errors.ERROR_ACCESS_DENIED &&
- Interop.Kernel32.GetExitCodeProcess(handle, out int localExitCode) && localExitCode != Interop.Kernel32.HandleOptions.STILL_ACTIVE)
- {
- return;
- }
-
- throw exception;
- }
+ handle.Kill();
  }
  }
 

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Unix.cs

@@ -27,7 +27,7 @@ public static bool IsProcessRunning(int processId)
  {
  // kill with signal==0 means to not actually send a signal.
  // If we get back 0, the process is still alive.
- int output = Interop.Sys.Kill(processId, Interop.Sys.Signals.None);
+ int output = Interop.Sys.Kill(processId, 0);
  // If kill set errno=EPERM, assume querying process is alive.
  return 0 == output || (-1 == output && Interop.Error.EPERM == Interop.Sys.GetLastError());
  }

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessWaitState.Unix.cs

@@ -351,7 +351,7 @@ private void CheckForNonChildExit()
  bool exited;
  // We won't be able to get an exit code, but we'll at least be able to determine if the process is
  // still running.
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.None); // None means don't send a signal
+ int killResult = Interop.Sys.Kill(_processId, 0); // 0 means don't send a signal, used to check if process is still alive
  if (killResult == 0)
  {
  // Process is still running. This could also be a defunct process that has completed

src/libraries/System.Diagnostics.Process/tests/Interop.cs

@@ -73,6 +73,9 @@ public struct SID_AND_ATTRIBUTES
  }
 
 
+ [DllImport("kernel32.dll", SetLastError = true)]
+ internal static extern SafeProcessHandle OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
+
  [DllImport("kernel32.dll", SetLastError = true)]
  [return: MarshalAs(UnmanagedType.Bool)]
  public static extern bool GenerateConsoleCtrlEvent(uint dwCtrlEvent, uint dwProcessGroupId);

src/libraries/System.Diagnostics.Process/tests/ProcessTests.Unix.cs

@@ -909,18 +909,12 @@ public async Task Kill_ExitedNonChildProcess_DoesNotThrow(bool killTree)
  using (Process nonChildProcess = CreateNonChildProcess())
  {
  // Kill the process.
- int rv = kill(nonChildProcess.Id, SIGKILL);
- Assert.Equal(0, rv);
+ Assert.True(nonChildProcess.SafeHandle.Signal(PosixSignal.SIGKILL));
 
  // Wait until the process is reaped.
- while (rv == 0)
+ while (!nonChildProcess.HasExited)
  {
- rv = kill(nonChildProcess.Id, 0);
- if (rv == 0)
- {
- // process still exists, wait some time.
- await Task.Delay(100);
- }
+ await Task.Delay(100);
 
  DateTime now = DateTime.UtcNow;
  if (start.Ticks + (Helpers.PassingTestTimeoutMilliseconds * 10_000) <= now.Ticks)
@@ -1024,11 +1018,6 @@ private static unsafe HashSet<uint> GetGroups()
  [DllImport("libc")]
  private static extern unsafe int setgroups(int length, uint* groups);
 
- private const int SIGKILL = 9;
-
- [DllImport("libc", SetLastError = true)]
- private static extern int kill(int pid, int sig);
-
  [DllImport("libc", SetLastError = true)]
  private static extern int open(string pathname, int flags);
 
@@ -1062,14 +1051,7 @@ private static string StartAndReadToEnd(string filename, string[] arguments)
  }
  }
 
- private static void SendSignal(PosixSignal signal, int processId)
- {
- int result = kill(processId, Interop.Sys.GetPlatformSignalNumber(signal));
- if (result != 0)
- {
- throw new Win32Exception(Marshal.GetLastWin32Error(), $"Failed to send signal {signal} to process {processId}");
- }
- }
+ private static void SendSignal(PosixSignal signal, Process process) => Assert.True(process.SafeHandle.Signal(signal));
 
  private static unsafe void ReEnableCtrlCHandlerIfNeeded(PosixSignal signal) { }
 
@@ -1115,7 +1097,7 @@ public void ChildProcess_WithParentSignalHandler_CanReceiveSignals()
  AssertRemoteProcessStandardOutputLine(childHandle, ChildReadyMessage, WaitInMS);
 
  // Send SIGCONT to the child process
-SendSignal(PosixSignal.SIGCONT, childHandle.Process.Id);
+Assert.True(childHandle.Process.SafeHandle.Signal(PosixSignal.SIGCONT));
 
  Assert.True(childHandle.Process.WaitForExit(WaitInMS));
  Assert.Equal(RemotelyInvokable.SuccessExitCode, childHandle.Process.ExitCode);

src/libraries/System.Diagnostics.Process/tests/ProcessTests.Windows.cs

@@ -80,7 +80,7 @@ private string WriteScriptFile(string directory, string name, int returnValue)
  return filename;
  }
 
- private static void SendSignal(PosixSignal signal, int processId)
+ private static void SendSignal(PosixSignal signal, Process process)
  {
  uint dwCtrlEvent = signal switch
  {
@@ -89,7 +89,7 @@ private static void SendSignal(PosixSignal signal, int processId)
  _ => throw new ArgumentOutOfRangeException(nameof(signal))
  };
 
- if (!Interop.GenerateConsoleCtrlEvent(dwCtrlEvent, (uint)processId))
+ if (!Interop.GenerateConsoleCtrlEvent(dwCtrlEvent, (uint)process.Id))
  {
  int error = Marshal.GetLastWin32Error();
  if (error == Interop.Errors.ERROR_INVALID_FUNCTION && PlatformDetection.IsInContainer)

src/libraries/System.Diagnostics.Process/tests/ProcessTests.cs

@@ -170,7 +170,7 @@ public void TestCreateNewProcessGroup_HandlerReceivesExpectedSignal(PosixSignal
 
  try
  {
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
 
  Assert.True(remoteHandle.Process.WaitForExit(WaitInMS));
  Assert.Equal(0, remoteHandle.Process.ExitCode);
@@ -243,7 +243,7 @@ public void SignalHandler_CanDisposeInHandler(PosixSignal signal)
  {
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalRegistrationCreatedMessage, WaitInMS);
 
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
 
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalHandlerStartedMessage, WaitInMS);
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalHandlerDisposedMessage, WaitInMS);
@@ -253,11 +253,11 @@ public void SignalHandler_CanDisposeInHandler(PosixSignal signal)
  if (PlatformDetection.IsMonoRuntime && signal == PosixSignal.SIGQUIT && !PlatformDetection.IsWindows)
  {
  // Terminate process using SIGTERM instead.
- SendSignal(PosixSignal.SIGTERM, remoteHandle.Process.Id);
+ SendSignal(PosixSignal.SIGTERM, remoteHandle.Process);
  }
  else
  {
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
  }
 
  Assert.True(remoteHandle.Process.WaitForExit(WaitInMS));

src/libraries/Common/src/Interop/Unix/System.Native/Interop.Kill.cs

@@ -1,21 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
 using System.Runtime.InteropServices;
 
 internal static partial class Interop
 {
  internal static partial class Sys
  {
- internal enum Signals : int
- {
- None = 0,
- SIGKILL = 9,
- SIGSTOP = 19
- }
-
  [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_Kill", SetLastError = true)]
- internal static partial int Kill(int pid, Signals signal);
+ internal static partial int Kill(int pid, int signal);
  }
 }

src/libraries/Common/src/Interop/Unix/System.Native/Interop.PosixSignal.cs

@@ -24,5 +24,9 @@ internal static partial class Sys
  [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetPlatformSignalNumber")]
  [SuppressGCTransition]
  internal static partial int GetPlatformSignalNumber(PosixSignal signal);
+
+ [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetPlatformSIGSTOP")]
+ [SuppressGCTransition]
+ internal static partial int GetPlatformSIGSTOP();
  }
 }

src/libraries/System.Diagnostics.Process/ref/System.Diagnostics.Process.cs

@@ -15,6 +15,14 @@ public SafeProcessHandle(System.IntPtr existingHandle, bool ownsHandle) : base (
  [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
  [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
  [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
+ public void Kill() { }
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+ [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
+ public bool Signal(System.Runtime.InteropServices.PosixSignal signal) { throw null; }
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+ [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
  public static Microsoft.Win32.SafeHandles.SafeProcessHandle Start(System.Diagnostics.ProcessStartInfo startInfo) { throw null; }
  }
 }

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.Unix.cs

@@ -59,6 +59,36 @@ protected override bool ReleaseHandle()
  // On Unix, we don't use process descriptors yet, so we can't get PID.
  private static int GetProcessIdCore() => throw new PlatformNotSupportedException();
 
+ private bool SignalCore(PosixSignal signal)
+ {
+ if (ProcessUtils.PlatformDoesNotSupportProcessStartAndKill)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ int signalNumber = Interop.Sys.GetPlatformSignalNumber(signal);
+ if (signalNumber == 0)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ int killResult = Interop.Sys.Kill(ProcessId, signalNumber);
+ if (killResult != 0)
+ {
+ Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
+
+ // Return false if the process has already exited (or never existed).
+ if (errorInfo.Error == Interop.Error.ESRCH)
+ {
+ return false;
+ }
+
+ throw new Win32Exception(errorInfo.RawErrno); // same exception as on Windows
+ }
+
+ return true;
+ }
+
  private delegate SafeProcessHandle StartWithShellExecuteDelegate(ProcessStartInfo startInfo, SafeFileHandle? stdinHandle, SafeFileHandle? stdoutHandle, SafeFileHandle? stderrHandle, out ProcessWaitState.Holder? waitStateHolder);
  private static StartWithShellExecuteDelegate? s_startWithShellExecute;
 

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.Windows.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Security;
@@ -330,5 +331,31 @@ Interop.Shell32.SE_ERR_DDEBUSY or
  }
 
  private int GetProcessIdCore() => Interop.Kernel32.GetProcessId(this);
+
+ private bool SignalCore(PosixSignal signal)
+ {
+ // On Windows, only SIGKILL is supported, mapped to TerminateProcess.
+ if (signal != PosixSignal.SIGKILL)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ if (!Interop.Kernel32.TerminateProcess(this, -1))
+ {
+ int errorCode = Marshal.GetLastWin32Error();
+
+ // Return false if the process has already exited.
+ if (errorCode == Interop.Errors.ERROR_ACCESS_DENIED &&
+ Interop.Kernel32.GetExitCodeProcess(this, out int exitCode) &&
+ exitCode != Interop.Kernel32.HandleOptions.STILL_ACTIVE)
+ {
+ return false;
+ }
+
+ throw new Win32Exception(errorCode);
+ }
+
+ return true;
+ }
  }
 }

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.cs

@@ -11,9 +11,11 @@
 ===========================================================*/
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.Serialization;
 using System.Runtime.Versioning;
+using System.Runtime.InteropServices;
 
 namespace Microsoft.Win32.SafeHandles
 {
@@ -123,6 +125,48 @@ public static SafeProcessHandle Start(ProcessStartInfo startInfo)
  return StartCore(startInfo, childInputHandle, childOutputHandle, childErrorHandle);
  }
 
+ /// <summary>
+ /// Sends a request to the OS to terminate the process.
+ /// </summary>
+ /// <remarks>
+ /// This method does not throw if the process has already exited.
+ /// On Windows, the handle must have <c>PROCESS_TERMINATE</c> access.
+ /// </remarks>
+ /// <exception cref="InvalidOperationException">The handle is invalid.</exception>
+ /// <exception cref="Win32Exception">The process could not be terminated.</exception>
+ [UnsupportedOSPlatform("ios")]
+ [UnsupportedOSPlatform("tvos")]
+ [SupportedOSPlatform("maccatalyst")]
+ public void Kill()
+ {
+ Validate();
+ SignalCore(PosixSignal.SIGKILL);
+ }
+
+ /// <summary>
+ /// Sends a signal to the process.
+ /// </summary>
+ /// <param name="signal">The signal to send.</param>
+ /// <returns>
+ /// <see langword="true"/> if the signal was sent successfully;
+ /// <see langword="false"/> if the process has already exited (or never existed) and the signal was not delivered.
+ /// </returns>
+ /// <remarks>
+ /// On Windows, only <see cref="PosixSignal.SIGKILL"/> is supported and is mapped to <see cref="Kill"/>.
+ /// On Windows, the handle must have <c>PROCESS_TERMINATE</c> access.
+ /// </remarks>
+ /// <exception cref="InvalidOperationException">The handle is invalid.</exception>
+ /// <exception cref="PlatformNotSupportedException">The specified signal is not supported on this platform.</exception>
+ /// <exception cref="Win32Exception">The signal could not be sent.</exception>
+ [UnsupportedOSPlatform("ios")]
+ [UnsupportedOSPlatform("tvos")]
+ [SupportedOSPlatform("maccatalyst")]
+ public bool Signal(PosixSignal signal)
+ {
+ Validate();
+ return SignalCore(signal);
+ }
+
  private void Validate()
  {
  if (IsInvalid)

src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj

@@ -263,6 +263,8 @@
  Link="Common\Interop\Unix\Interop.InitializeTerminalAndSignalHandling.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Kill.cs"
  Link="Common\Interop\Unix\Interop.Kill.cs" />
+ <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.PosixSignal.cs"
+ Link="Common\Interop\Unix\Interop.PosixSignal.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.ReadLink.cs"
  Link="Common\Interop\Unix\Interop.ReadLink.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.RegisterForSigChld.cs"

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs

@@ -69,7 +69,7 @@ public void Kill()
  return;
  }
 
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGKILL);
+ int killResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSignalNumber(PosixSignal.SIGKILL));
  if (killResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();
@@ -105,7 +105,7 @@ private void KillTree(ref List<Exception>? exceptions)
 
  // Stop the process, so it won't start additional children.
  // This is best effort: kill can return before the process is stopped.
- int stopResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGSTOP);
+ int stopResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSIGSTOP());
  if (stopResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();
@@ -119,7 +119,7 @@ private void KillTree(ref List<Exception>? exceptions)
 
  List<Process> children = GetChildProcesses();
 
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGKILL);
+ int killResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSignalNumber(PosixSignal.SIGKILL));
  if (killResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Windows.cs

@@ -93,20 +93,7 @@ public void Kill()
  if (handle.IsInvalid)
  return;
 
- if (!Interop.Kernel32.TerminateProcess(handle, -1))
- {
- // Capture the exception
- var exception = new Win32Exception();
-
- // Don't throw if the process has exited.
- if (exception.NativeErrorCode == Interop.Errors.ERROR_ACCESS_DENIED &&
- Interop.Kernel32.GetExitCodeProcess(handle, out int localExitCode) && localExitCode != Interop.Kernel32.HandleOptions.STILL_ACTIVE)
- {
- return;
- }
-
- throw exception;
- }
+ handle.Kill();
  }
  }
 

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Unix.cs

@@ -27,7 +27,7 @@ public static bool IsProcessRunning(int processId)
  {
  // kill with signal==0 means to not actually send a signal.
  // If we get back 0, the process is still alive.
- int output = Interop.Sys.Kill(processId, Interop.Sys.Signals.None);
+ int output = Interop.Sys.Kill(processId, 0);
  // If kill set errno=EPERM, assume querying process is alive.
  return 0 == output || (-1 == output && Interop.Error.EPERM == Interop.Sys.GetLastError());
  }

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessWaitState.Unix.cs

@@ -351,7 +351,7 @@ private void CheckForNonChildExit()
  bool exited;
  // We won't be able to get an exit code, but we'll at least be able to determine if the process is
  // still running.
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.None); // None means don't send a signal
+ int killResult = Interop.Sys.Kill(_processId, 0); // 0 means don't send a signal, used to check if process is still alive
  if (killResult == 0)
  {
  // Process is still running. This could also be a defunct process that has completed

src/libraries/System.Diagnostics.Process/tests/Interop.cs

@@ -73,6 +73,9 @@ public struct SID_AND_ATTRIBUTES
  }
 
 
+ [DllImport("kernel32.dll", SetLastError = true)]
+ internal static extern SafeProcessHandle OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
+
  [DllImport("kernel32.dll", SetLastError = true)]
  [return: MarshalAs(UnmanagedType.Bool)]
  public static extern bool GenerateConsoleCtrlEvent(uint dwCtrlEvent, uint dwProcessGroupId);

src/libraries/System.Diagnostics.Process/tests/ProcessTests.Unix.cs

@@ -909,18 +909,12 @@ public async Task Kill_ExitedNonChildProcess_DoesNotThrow(bool killTree)
  using (Process nonChildProcess = CreateNonChildProcess())
  {
  // Kill the process.
- int rv = kill(nonChildProcess.Id, SIGKILL);
- Assert.Equal(0, rv);
+ Assert.True(nonChildProcess.SafeHandle.Signal(PosixSignal.SIGKILL));
 
  // Wait until the process is reaped.
- while (rv == 0)
+ while (!nonChildProcess.HasExited)
  {
- rv = kill(nonChildProcess.Id, 0);
- if (rv == 0)
- {
- // process still exists, wait some time.
- await Task.Delay(100);
- }
+ await Task.Delay(100);
 
  DateTime now = DateTime.UtcNow;
  if (start.Ticks + (Helpers.PassingTestTimeoutMilliseconds * 10_000) <= now.Ticks)
@@ -1024,11 +1018,6 @@ private static unsafe HashSet<uint> GetGroups()
  [DllImport("libc")]
  private static extern unsafe int setgroups(int length, uint* groups);
 
- private const int SIGKILL = 9;
-
- [DllImport("libc", SetLastError = true)]
- private static extern int kill(int pid, int sig);
-
  [DllImport("libc", SetLastError = true)]
  private static extern int open(string pathname, int flags);
 
@@ -1062,14 +1051,7 @@ private static string StartAndReadToEnd(string filename, string[] arguments)
  }
  }
 
- private static void SendSignal(PosixSignal signal, int processId)
- {
- int result = kill(processId, Interop.Sys.GetPlatformSignalNumber(signal));
- if (result != 0)
- {
- throw new Win32Exception(Marshal.GetLastWin32Error(), $"Failed to send signal {signal} to process {processId}");
- }
- }
+ private static void SendSignal(PosixSignal signal, Process process) => Assert.True(process.SafeHandle.Signal(signal));
 
  private static unsafe void ReEnableCtrlCHandlerIfNeeded(PosixSignal signal) { }
 
@@ -1115,7 +1097,7 @@ public void ChildProcess_WithParentSignalHandler_CanReceiveSignals()
  AssertRemoteProcessStandardOutputLine(childHandle, ChildReadyMessage, WaitInMS);
 
  // Send SIGCONT to the child process
-SendSignal(PosixSignal.SIGCONT, childHandle.Process.Id);
+Assert.True(childHandle.Process.SafeHandle.Signal(PosixSignal.SIGCONT));
 
  Assert.True(childHandle.Process.WaitForExit(WaitInMS));
  Assert.Equal(RemotelyInvokable.SuccessExitCode, childHandle.Process.ExitCode);

src/libraries/System.Diagnostics.Process/tests/ProcessTests.Windows.cs

@@ -80,7 +80,7 @@ private string WriteScriptFile(string directory, string name, int returnValue)
  return filename;
  }
 
- private static void SendSignal(PosixSignal signal, int processId)
+ private static void SendSignal(PosixSignal signal, Process process)
  {
  uint dwCtrlEvent = signal switch
  {
@@ -89,7 +89,7 @@ private static void SendSignal(PosixSignal signal, int processId)
  _ => throw new ArgumentOutOfRangeException(nameof(signal))
  };
 
- if (!Interop.GenerateConsoleCtrlEvent(dwCtrlEvent, (uint)processId))
+ if (!Interop.GenerateConsoleCtrlEvent(dwCtrlEvent, (uint)process.Id))
  {
  int error = Marshal.GetLastWin32Error();
  if (error == Interop.Errors.ERROR_INVALID_FUNCTION && PlatformDetection.IsInContainer)

src/libraries/System.Diagnostics.Process/tests/ProcessTests.cs

@@ -170,7 +170,7 @@ public void TestCreateNewProcessGroup_HandlerReceivesExpectedSignal(PosixSignal
 
  try
  {
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
 
  Assert.True(remoteHandle.Process.WaitForExit(WaitInMS));
  Assert.Equal(0, remoteHandle.Process.ExitCode);
@@ -243,7 +243,7 @@ public void SignalHandler_CanDisposeInHandler(PosixSignal signal)
  {
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalRegistrationCreatedMessage, WaitInMS);
 
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
 
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalHandlerStartedMessage, WaitInMS);
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalHandlerDisposedMessage, WaitInMS);
@@ -253,11 +253,11 @@ public void SignalHandler_CanDisposeInHandler(PosixSignal signal)
  if (PlatformDetection.IsMonoRuntime && signal == PosixSignal.SIGQUIT && !PlatformDetection.IsWindows)
  {
  // Terminate process using SIGTERM instead.
- SendSignal(PosixSignal.SIGTERM, remoteHandle.Process.Id);
+ SendSignal(PosixSignal.SIGTERM, remoteHandle.Process);
  }
  else
  {
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
  }
 
  Assert.True(remoteHandle.Process.WaitForExit(WaitInMS));

src/libraries/Common/src/Interop/Unix/System.Native/Interop.Kill.cs

@@ -1,21 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
 using System.Runtime.InteropServices;
 
 internal static partial class Interop
 {
  internal static partial class Sys
  {
- internal enum Signals : int
- {
- None = 0,
- SIGKILL = 9,
- SIGSTOP = 19
- }
-
  [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_Kill", SetLastError = true)]
- internal static partial int Kill(int pid, Signals signal);
+ internal static partial int Kill(int pid, int signal);
  }
 }

src/libraries/Common/src/Interop/Unix/System.Native/Interop.PosixSignal.cs

@@ -24,5 +24,9 @@ internal static partial class Sys
  [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetPlatformSignalNumber")]
  [SuppressGCTransition]
  internal static partial int GetPlatformSignalNumber(PosixSignal signal);
+
+ [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetPlatformSIGSTOP")]
+ [SuppressGCTransition]
+ internal static partial int GetPlatformSIGSTOP();
  }
 }

src/libraries/System.Diagnostics.Process/ref/System.Diagnostics.Process.cs

@@ -15,6 +15,14 @@ public SafeProcessHandle(System.IntPtr existingHandle, bool ownsHandle) : base (
  [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
  [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
  [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
+ public void Kill() { }
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+ [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
+ public bool Signal(System.Runtime.InteropServices.PosixSignal signal) { throw null; }
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+ [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
  public static Microsoft.Win32.SafeHandles.SafeProcessHandle Start(System.Diagnostics.ProcessStartInfo startInfo) { throw null; }
  }
 }

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.Unix.cs

@@ -59,6 +59,36 @@ protected override bool ReleaseHandle()
  // On Unix, we don't use process descriptors yet, so we can't get PID.
  private static int GetProcessIdCore() => throw new PlatformNotSupportedException();
 
+ private bool SignalCore(PosixSignal signal)
+ {
+ if (ProcessUtils.PlatformDoesNotSupportProcessStartAndKill)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ int signalNumber = Interop.Sys.GetPlatformSignalNumber(signal);
+ if (signalNumber == 0)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ int killResult = Interop.Sys.Kill(ProcessId, signalNumber);
+ if (killResult != 0)
+ {
+ Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
+
+ // Return false if the process has already exited (or never existed).
+ if (errorInfo.Error == Interop.Error.ESRCH)
+ {
+ return false;
+ }
+
+ throw new Win32Exception(errorInfo.RawErrno); // same exception as on Windows
+ }
+
+ return true;
+ }
+
  private delegate SafeProcessHandle StartWithShellExecuteDelegate(ProcessStartInfo startInfo, SafeFileHandle? stdinHandle, SafeFileHandle? stdoutHandle, SafeFileHandle? stderrHandle, out ProcessWaitState.Holder? waitStateHolder);
  private static StartWithShellExecuteDelegate? s_startWithShellExecute;
 

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.Windows.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Security;
@@ -330,5 +331,31 @@ Interop.Shell32.SE_ERR_DDEBUSY or
  }
 
  private int GetProcessIdCore() => Interop.Kernel32.GetProcessId(this);
+
+ private bool SignalCore(PosixSignal signal)
+ {
+ // On Windows, only SIGKILL is supported, mapped to TerminateProcess.
+ if (signal != PosixSignal.SIGKILL)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ if (!Interop.Kernel32.TerminateProcess(this, -1))
+ {
+ int errorCode = Marshal.GetLastWin32Error();
+
+ // Return false if the process has already exited.
+ if (errorCode == Interop.Errors.ERROR_ACCESS_DENIED &&
+ Interop.Kernel32.GetExitCodeProcess(this, out int exitCode) &&
+ exitCode != Interop.Kernel32.HandleOptions.STILL_ACTIVE)
+ {
+ return false;
+ }
+
+ throw new Win32Exception(errorCode);
+ }
+
+ return true;
+ }
  }
 }

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.cs

@@ -11,9 +11,11 @@
 ===========================================================*/
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.Serialization;
 using System.Runtime.Versioning;
+using System.Runtime.InteropServices;
 
 namespace Microsoft.Win32.SafeHandles
 {
@@ -123,6 +125,48 @@ public static SafeProcessHandle Start(ProcessStartInfo startInfo)
  return StartCore(startInfo, childInputHandle, childOutputHandle, childErrorHandle);
  }
 
+ /// <summary>
+ /// Sends a request to the OS to terminate the process.
+ /// </summary>
+ /// <remarks>
+ /// This method does not throw if the process has already exited.
+ /// On Windows, the handle must have <c>PROCESS_TERMINATE</c> access.
+ /// </remarks>
+ /// <exception cref="InvalidOperationException">The handle is invalid.</exception>
+ /// <exception cref="Win32Exception">The process could not be terminated.</exception>
+ [UnsupportedOSPlatform("ios")]
+ [UnsupportedOSPlatform("tvos")]
+ [SupportedOSPlatform("maccatalyst")]
+ public void Kill()
+ {
+ Validate();
+ SignalCore(PosixSignal.SIGKILL);
+ }
+
+ /// <summary>
+ /// Sends a signal to the process.
+ /// </summary>
+ /// <param name="signal">The signal to send.</param>
+ /// <returns>
+ /// <see langword="true"/> if the signal was sent successfully;
+ /// <see langword="false"/> if the process has already exited (or never existed) and the signal was not delivered.
+ /// </returns>
+ /// <remarks>
+ /// On Windows, only <see cref="PosixSignal.SIGKILL"/> is supported and is mapped to <see cref="Kill"/>.
+ /// On Windows, the handle must have <c>PROCESS_TERMINATE</c> access.
+ /// </remarks>
+ /// <exception cref="InvalidOperationException">The handle is invalid.</exception>
+ /// <exception cref="PlatformNotSupportedException">The specified signal is not supported on this platform.</exception>
+ /// <exception cref="Win32Exception">The signal could not be sent.</exception>
+ [UnsupportedOSPlatform("ios")]
+ [UnsupportedOSPlatform("tvos")]
+ [SupportedOSPlatform("maccatalyst")]
+ public bool Signal(PosixSignal signal)
+ {
+ Validate();
+ return SignalCore(signal);
+ }
+
  private void Validate()
  {
  if (IsInvalid)

src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj

@@ -263,6 +263,8 @@
  Link="Common\Interop\Unix\Interop.InitializeTerminalAndSignalHandling.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Kill.cs"
  Link="Common\Interop\Unix\Interop.Kill.cs" />
+ <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.PosixSignal.cs"
+ Link="Common\Interop\Unix\Interop.PosixSignal.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.ReadLink.cs"
  Link="Common\Interop\Unix\Interop.ReadLink.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.RegisterForSigChld.cs"

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs

@@ -69,7 +69,7 @@ public void Kill()
  return;
  }
 
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGKILL);
+ int killResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSignalNumber(PosixSignal.SIGKILL));
  if (killResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();
@@ -105,7 +105,7 @@ private void KillTree(ref List<Exception>? exceptions)
 
  // Stop the process, so it won't start additional children.
  // This is best effort: kill can return before the process is stopped.
- int stopResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGSTOP);
+ int stopResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSIGSTOP());
  if (stopResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();
@@ -119,7 +119,7 @@ private void KillTree(ref List<Exception>? exceptions)
 
  List<Process> children = GetChildProcesses();
 
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGKILL);
+ int killResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSignalNumber(PosixSignal.SIGKILL));
  if (killResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Windows.cs

@@ -93,20 +93,7 @@ public void Kill()
  if (handle.IsInvalid)
  return;
 
- if (!Interop.Kernel32.TerminateProcess(handle, -1))
- {
- // Capture the exception
- var exception = new Win32Exception();
-
- // Don't throw if the process has exited.
- if (exception.NativeErrorCode == Interop.Errors.ERROR_ACCESS_DENIED &&
- Interop.Kernel32.GetExitCodeProcess(handle, out int localExitCode) && localExitCode != Interop.Kernel32.HandleOptions.STILL_ACTIVE)
- {
- return;
- }
-
- throw exception;
- }
+ handle.Kill();
  }
  }
 

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Unix.cs

@@ -27,7 +27,7 @@ public static bool IsProcessRunning(int processId)
  {
  // kill with signal==0 means to not actually send a signal.
  // If we get back 0, the process is still alive.
- int output = Interop.Sys.Kill(processId, Interop.Sys.Signals.None);
+ int output = Interop.Sys.Kill(processId, 0);
  // If kill set errno=EPERM, assume querying process is alive.
  return 0 == output || (-1 == output && Interop.Error.EPERM == Interop.Sys.GetLastError());
  }

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessWaitState.Unix.cs

@@ -351,7 +351,7 @@ private void CheckForNonChildExit()
  bool exited;
  // We won't be able to get an exit code, but we'll at least be able to determine if the process is
  // still running.
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.None); // None means don't send a signal
+ int killResult = Interop.Sys.Kill(_processId, 0); // 0 means don't send a signal, used to check if process is still alive
  if (killResult == 0)
  {
  // Process is still running. This could also be a defunct process that has completed

src/libraries/System.Diagnostics.Process/tests/Interop.cs

@@ -73,6 +73,9 @@ public struct SID_AND_ATTRIBUTES
  }
 
 
+ [DllImport("kernel32.dll", SetLastError = true)]
+ internal static extern SafeProcessHandle OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
+
  [DllImport("kernel32.dll", SetLastError = true)]
  [return: MarshalAs(UnmanagedType.Bool)]
  public static extern bool GenerateConsoleCtrlEvent(uint dwCtrlEvent, uint dwProcessGroupId);

src/libraries/System.Diagnostics.Process/tests/ProcessTests.Unix.cs

@@ -909,18 +909,12 @@ public async Task Kill_ExitedNonChildProcess_DoesNotThrow(bool killTree)
  using (Process nonChildProcess = CreateNonChildProcess())
  {
  // Kill the process.
- int rv = kill(nonChildProcess.Id, SIGKILL);
- Assert.Equal(0, rv);
+ Assert.True(nonChildProcess.SafeHandle.Signal(PosixSignal.SIGKILL));
 
  // Wait until the process is reaped.
- while (rv == 0)
+ while (!nonChildProcess.HasExited)
  {
- rv = kill(nonChildProcess.Id, 0);
- if (rv == 0)
- {
- // process still exists, wait some time.
- await Task.Delay(100);
- }
+ await Task.Delay(100);
 
  DateTime now = DateTime.UtcNow;
  if (start.Ticks + (Helpers.PassingTestTimeoutMilliseconds * 10_000) <= now.Ticks)
@@ -1024,11 +1018,6 @@ private static unsafe HashSet<uint> GetGroups()
  [DllImport("libc")]
  private static extern unsafe int setgroups(int length, uint* groups);
 
- private const int SIGKILL = 9;
-
- [DllImport("libc", SetLastError = true)]
- private static extern int kill(int pid, int sig);
-
  [DllImport("libc", SetLastError = true)]
  private static extern int open(string pathname, int flags);
 
@@ -1062,14 +1051,7 @@ private static string StartAndReadToEnd(string filename, string[] arguments)
  }
  }
 
- private static void SendSignal(PosixSignal signal, int processId)
- {
- int result = kill(processId, Interop.Sys.GetPlatformSignalNumber(signal));
- if (result != 0)
- {
- throw new Win32Exception(Marshal.GetLastWin32Error(), $"Failed to send signal {signal} to process {processId}");
- }
- }
+ private static void SendSignal(PosixSignal signal, Process process) => Assert.True(process.SafeHandle.Signal(signal));
 
  private static unsafe void ReEnableCtrlCHandlerIfNeeded(PosixSignal signal) { }
 
@@ -1115,7 +1097,7 @@ public void ChildProcess_WithParentSignalHandler_CanReceiveSignals()
  AssertRemoteProcessStandardOutputLine(childHandle, ChildReadyMessage, WaitInMS);
 
  // Send SIGCONT to the child process
-SendSignal(PosixSignal.SIGCONT, childHandle.Process.Id);
+Assert.True(childHandle.Process.SafeHandle.Signal(PosixSignal.SIGCONT));
 
  Assert.True(childHandle.Process.WaitForExit(WaitInMS));
  Assert.Equal(RemotelyInvokable.SuccessExitCode, childHandle.Process.ExitCode);

src/libraries/System.Diagnostics.Process/tests/ProcessTests.Windows.cs

@@ -80,7 +80,7 @@ private string WriteScriptFile(string directory, string name, int returnValue)
  return filename;
  }
 
- private static void SendSignal(PosixSignal signal, int processId)
+ private static void SendSignal(PosixSignal signal, Process process)
  {
  uint dwCtrlEvent = signal switch
  {
@@ -89,7 +89,7 @@ private static void SendSignal(PosixSignal signal, int processId)
  _ => throw new ArgumentOutOfRangeException(nameof(signal))
  };
 
- if (!Interop.GenerateConsoleCtrlEvent(dwCtrlEvent, (uint)processId))
+ if (!Interop.GenerateConsoleCtrlEvent(dwCtrlEvent, (uint)process.Id))
  {
  int error = Marshal.GetLastWin32Error();
  if (error == Interop.Errors.ERROR_INVALID_FUNCTION && PlatformDetection.IsInContainer)

src/libraries/System.Diagnostics.Process/tests/ProcessTests.cs

@@ -170,7 +170,7 @@ public void TestCreateNewProcessGroup_HandlerReceivesExpectedSignal(PosixSignal
 
  try
  {
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
 
  Assert.True(remoteHandle.Process.WaitForExit(WaitInMS));
  Assert.Equal(0, remoteHandle.Process.ExitCode);
@@ -243,7 +243,7 @@ public void SignalHandler_CanDisposeInHandler(PosixSignal signal)
  {
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalRegistrationCreatedMessage, WaitInMS);
 
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
 
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalHandlerStartedMessage, WaitInMS);
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalHandlerDisposedMessage, WaitInMS);
@@ -253,11 +253,11 @@ public void SignalHandler_CanDisposeInHandler(PosixSignal signal)
  if (PlatformDetection.IsMonoRuntime && signal == PosixSignal.SIGQUIT && !PlatformDetection.IsWindows)
  {
  // Terminate process using SIGTERM instead.
- SendSignal(PosixSignal.SIGTERM, remoteHandle.Process.Id);
+ SendSignal(PosixSignal.SIGTERM, remoteHandle.Process);
  }
  else
  {
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
  }
 
  Assert.True(remoteHandle.Process.WaitForExit(WaitInMS));

src/libraries/Common/src/Interop/Unix/System.Native/Interop.Kill.cs

@@ -1,21 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
 using System.Runtime.InteropServices;
 
 internal static partial class Interop
 {
  internal static partial class Sys
  {
- internal enum Signals : int
- {
- None = 0,
- SIGKILL = 9,
- SIGSTOP = 19
- }
-
  [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_Kill", SetLastError = true)]
- internal static partial int Kill(int pid, Signals signal);
+ internal static partial int Kill(int pid, int signal);
  }
 }

src/libraries/Common/src/Interop/Unix/System.Native/Interop.PosixSignal.cs

@@ -24,5 +24,9 @@ internal static partial class Sys
  [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetPlatformSignalNumber")]
  [SuppressGCTransition]
  internal static partial int GetPlatformSignalNumber(PosixSignal signal);
+
+ [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetPlatformSIGSTOP")]
+ [SuppressGCTransition]
+ internal static partial int GetPlatformSIGSTOP();
  }
 }

src/libraries/System.Diagnostics.Process/ref/System.Diagnostics.Process.cs

@@ -15,6 +15,14 @@ public SafeProcessHandle(System.IntPtr existingHandle, bool ownsHandle) : base (
  [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
  [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
  [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
+ public void Kill() { }
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+ [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
+ public bool Signal(System.Runtime.InteropServices.PosixSignal signal) { throw null; }
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+ [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
  public static Microsoft.Win32.SafeHandles.SafeProcessHandle Start(System.Diagnostics.ProcessStartInfo startInfo) { throw null; }
  }
 }

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.Unix.cs

@@ -59,6 +59,36 @@ protected override bool ReleaseHandle()
  // On Unix, we don't use process descriptors yet, so we can't get PID.
  private static int GetProcessIdCore() => throw new PlatformNotSupportedException();
 
+ private bool SignalCore(PosixSignal signal)
+ {
+ if (ProcessUtils.PlatformDoesNotSupportProcessStartAndKill)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ int signalNumber = Interop.Sys.GetPlatformSignalNumber(signal);
+ if (signalNumber == 0)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ int killResult = Interop.Sys.Kill(ProcessId, signalNumber);
+ if (killResult != 0)
+ {
+ Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
+
+ // Return false if the process has already exited (or never existed).
+ if (errorInfo.Error == Interop.Error.ESRCH)
+ {
+ return false;
+ }
+
+ throw new Win32Exception(errorInfo.RawErrno); // same exception as on Windows
+ }
+
+ return true;
+ }
+
  private delegate SafeProcessHandle StartWithShellExecuteDelegate(ProcessStartInfo startInfo, SafeFileHandle? stdinHandle, SafeFileHandle? stdoutHandle, SafeFileHandle? stderrHandle, out ProcessWaitState.Holder? waitStateHolder);
  private static StartWithShellExecuteDelegate? s_startWithShellExecute;
 

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.Windows.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Security;
@@ -330,5 +331,31 @@ Interop.Shell32.SE_ERR_DDEBUSY or
  }
 
  private int GetProcessIdCore() => Interop.Kernel32.GetProcessId(this);
+
+ private bool SignalCore(PosixSignal signal)
+ {
+ // On Windows, only SIGKILL is supported, mapped to TerminateProcess.
+ if (signal != PosixSignal.SIGKILL)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ if (!Interop.Kernel32.TerminateProcess(this, -1))
+ {
+ int errorCode = Marshal.GetLastWin32Error();
+
+ // Return false if the process has already exited.
+ if (errorCode == Interop.Errors.ERROR_ACCESS_DENIED &&
+ Interop.Kernel32.GetExitCodeProcess(this, out int exitCode) &&
+ exitCode != Interop.Kernel32.HandleOptions.STILL_ACTIVE)
+ {
+ return false;
+ }
+
+ throw new Win32Exception(errorCode);
+ }
+
+ return true;
+ }
  }
 }

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.cs

@@ -11,9 +11,11 @@
 ===========================================================*/
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.Serialization;
 using System.Runtime.Versioning;
+using System.Runtime.InteropServices;
 
 namespace Microsoft.Win32.SafeHandles
 {
@@ -123,6 +125,48 @@ public static SafeProcessHandle Start(ProcessStartInfo startInfo)
  return StartCore(startInfo, childInputHandle, childOutputHandle, childErrorHandle);
  }
 
+ /// <summary>
+ /// Sends a request to the OS to terminate the process.
+ /// </summary>
+ /// <remarks>
+ /// This method does not throw if the process has already exited.
+ /// On Windows, the handle must have <c>PROCESS_TERMINATE</c> access.
+ /// </remarks>
+ /// <exception cref="InvalidOperationException">The handle is invalid.</exception>
+ /// <exception cref="Win32Exception">The process could not be terminated.</exception>
+ [UnsupportedOSPlatform("ios")]
+ [UnsupportedOSPlatform("tvos")]
+ [SupportedOSPlatform("maccatalyst")]
+ public void Kill()
+ {
+ Validate();
+ SignalCore(PosixSignal.SIGKILL);
+ }
+
+ /// <summary>
+ /// Sends a signal to the process.
+ /// </summary>
+ /// <param name="signal">The signal to send.</param>
+ /// <returns>
+ /// <see langword="true"/> if the signal was sent successfully;
+ /// <see langword="false"/> if the process has already exited (or never existed) and the signal was not delivered.
+ /// </returns>
+ /// <remarks>
+ /// On Windows, only <see cref="PosixSignal.SIGKILL"/> is supported and is mapped to <see cref="Kill"/>.
+ /// On Windows, the handle must have <c>PROCESS_TERMINATE</c> access.
+ /// </remarks>
+ /// <exception cref="InvalidOperationException">The handle is invalid.</exception>
+ /// <exception cref="PlatformNotSupportedException">The specified signal is not supported on this platform.</exception>
+ /// <exception cref="Win32Exception">The signal could not be sent.</exception>
+ [UnsupportedOSPlatform("ios")]
+ [UnsupportedOSPlatform("tvos")]
+ [SupportedOSPlatform("maccatalyst")]
+ public bool Signal(PosixSignal signal)
+ {
+ Validate();
+ return SignalCore(signal);
+ }
+
  private void Validate()
  {
  if (IsInvalid)

src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj

@@ -263,6 +263,8 @@
  Link="Common\Interop\Unix\Interop.InitializeTerminalAndSignalHandling.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Kill.cs"
  Link="Common\Interop\Unix\Interop.Kill.cs" />
+ <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.PosixSignal.cs"
+ Link="Common\Interop\Unix\Interop.PosixSignal.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.ReadLink.cs"
  Link="Common\Interop\Unix\Interop.ReadLink.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.RegisterForSigChld.cs"

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs

@@ -69,7 +69,7 @@ public void Kill()
  return;
  }
 
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGKILL);
+ int killResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSignalNumber(PosixSignal.SIGKILL));
  if (killResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();
@@ -105,7 +105,7 @@ private void KillTree(ref List<Exception>? exceptions)
 
  // Stop the process, so it won't start additional children.
  // This is best effort: kill can return before the process is stopped.
- int stopResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGSTOP);
+ int stopResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSIGSTOP());
  if (stopResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();
@@ -119,7 +119,7 @@ private void KillTree(ref List<Exception>? exceptions)
 
  List<Process> children = GetChildProcesses();
 
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGKILL);
+ int killResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSignalNumber(PosixSignal.SIGKILL));
  if (killResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Windows.cs

@@ -93,20 +93,7 @@ public void Kill()
  if (handle.IsInvalid)
  return;
 
- if (!Interop.Kernel32.TerminateProcess(handle, -1))
- {
- // Capture the exception
- var exception = new Win32Exception();
-
- // Don't throw if the process has exited.
- if (exception.NativeErrorCode == Interop.Errors.ERROR_ACCESS_DENIED &&
- Interop.Kernel32.GetExitCodeProcess(handle, out int localExitCode) && localExitCode != Interop.Kernel32.HandleOptions.STILL_ACTIVE)
- {
- return;
- }
-
- throw exception;
- }
+ handle.Kill();
  }
  }
 

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Unix.cs

@@ -27,7 +27,7 @@ public static bool IsProcessRunning(int processId)
  {
  // kill with signal==0 means to not actually send a signal.
  // If we get back 0, the process is still alive.
- int output = Interop.Sys.Kill(processId, Interop.Sys.Signals.None);
+ int output = Interop.Sys.Kill(processId, 0);
  // If kill set errno=EPERM, assume querying process is alive.
  return 0 == output || (-1 == output && Interop.Error.EPERM == Interop.Sys.GetLastError());
  }

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessWaitState.Unix.cs

@@ -351,7 +351,7 @@ private void CheckForNonChildExit()
  bool exited;
  // We won't be able to get an exit code, but we'll at least be able to determine if the process is
  // still running.
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.None); // None means don't send a signal
+ int killResult = Interop.Sys.Kill(_processId, 0); // 0 means don't send a signal, used to check if process is still alive
  if (killResult == 0)
  {
  // Process is still running. This could also be a defunct process that has completed

src/libraries/System.Diagnostics.Process/tests/Interop.cs

@@ -73,6 +73,9 @@ public struct SID_AND_ATTRIBUTES
  }
 
 
+ [DllImport("kernel32.dll", SetLastError = true)]
+ internal static extern SafeProcessHandle OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
+
  [DllImport("kernel32.dll", SetLastError = true)]
  [return: MarshalAs(UnmanagedType.Bool)]
  public static extern bool GenerateConsoleCtrlEvent(uint dwCtrlEvent, uint dwProcessGroupId);

src/libraries/System.Diagnostics.Process/tests/ProcessTests.Unix.cs

@@ -909,18 +909,12 @@ public async Task Kill_ExitedNonChildProcess_DoesNotThrow(bool killTree)
  using (Process nonChildProcess = CreateNonChildProcess())
  {
  // Kill the process.
- int rv = kill(nonChildProcess.Id, SIGKILL);
- Assert.Equal(0, rv);
+ Assert.True(nonChildProcess.SafeHandle.Signal(PosixSignal.SIGKILL));
 
  // Wait until the process is reaped.
- while (rv == 0)
+ while (!nonChildProcess.HasExited)
  {
- rv = kill(nonChildProcess.Id, 0);
- if (rv == 0)
- {
- // process still exists, wait some time.
- await Task.Delay(100);
- }
+ await Task.Delay(100);
 
  DateTime now = DateTime.UtcNow;
  if (start.Ticks + (Helpers.PassingTestTimeoutMilliseconds * 10_000) <= now.Ticks)
@@ -1024,11 +1018,6 @@ private static unsafe HashSet<uint> GetGroups()
  [DllImport("libc")]
  private static extern unsafe int setgroups(int length, uint* groups);
 
- private const int SIGKILL = 9;
-
- [DllImport("libc", SetLastError = true)]
- private static extern int kill(int pid, int sig);
-
  [DllImport("libc", SetLastError = true)]
  private static extern int open(string pathname, int flags);
 
@@ -1062,14 +1051,7 @@ private static string StartAndReadToEnd(string filename, string[] arguments)
  }
  }
 
- private static void SendSignal(PosixSignal signal, int processId)
- {
- int result = kill(processId, Interop.Sys.GetPlatformSignalNumber(signal));
- if (result != 0)
- {
- throw new Win32Exception(Marshal.GetLastWin32Error(), $"Failed to send signal {signal} to process {processId}");
- }
- }
+ private static void SendSignal(PosixSignal signal, Process process) => Assert.True(process.SafeHandle.Signal(signal));
 
  private static unsafe void ReEnableCtrlCHandlerIfNeeded(PosixSignal signal) { }
 
@@ -1115,7 +1097,7 @@ public void ChildProcess_WithParentSignalHandler_CanReceiveSignals()
  AssertRemoteProcessStandardOutputLine(childHandle, ChildReadyMessage, WaitInMS);
 
  // Send SIGCONT to the child process
-SendSignal(PosixSignal.SIGCONT, childHandle.Process.Id);
+Assert.True(childHandle.Process.SafeHandle.Signal(PosixSignal.SIGCONT));
 
  Assert.True(childHandle.Process.WaitForExit(WaitInMS));
  Assert.Equal(RemotelyInvokable.SuccessExitCode, childHandle.Process.ExitCode);

src/libraries/System.Diagnostics.Process/tests/ProcessTests.Windows.cs

@@ -80,7 +80,7 @@ private string WriteScriptFile(string directory, string name, int returnValue)
  return filename;
  }
 
- private static void SendSignal(PosixSignal signal, int processId)
+ private static void SendSignal(PosixSignal signal, Process process)
  {
  uint dwCtrlEvent = signal switch
  {
@@ -89,7 +89,7 @@ private static void SendSignal(PosixSignal signal, int processId)
  _ => throw new ArgumentOutOfRangeException(nameof(signal))
  };
 
- if (!Interop.GenerateConsoleCtrlEvent(dwCtrlEvent, (uint)processId))
+ if (!Interop.GenerateConsoleCtrlEvent(dwCtrlEvent, (uint)process.Id))
  {
  int error = Marshal.GetLastWin32Error();
  if (error == Interop.Errors.ERROR_INVALID_FUNCTION && PlatformDetection.IsInContainer)

src/libraries/System.Diagnostics.Process/tests/ProcessTests.cs

@@ -170,7 +170,7 @@ public void TestCreateNewProcessGroup_HandlerReceivesExpectedSignal(PosixSignal
 
  try
  {
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
 
  Assert.True(remoteHandle.Process.WaitForExit(WaitInMS));
  Assert.Equal(0, remoteHandle.Process.ExitCode);
@@ -243,7 +243,7 @@ public void SignalHandler_CanDisposeInHandler(PosixSignal signal)
  {
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalRegistrationCreatedMessage, WaitInMS);
 
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
 
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalHandlerStartedMessage, WaitInMS);
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalHandlerDisposedMessage, WaitInMS);
@@ -253,11 +253,11 @@ public void SignalHandler_CanDisposeInHandler(PosixSignal signal)
  if (PlatformDetection.IsMonoRuntime && signal == PosixSignal.SIGQUIT && !PlatformDetection.IsWindows)
  {
  // Terminate process using SIGTERM instead.
- SendSignal(PosixSignal.SIGTERM, remoteHandle.Process.Id);
+ SendSignal(PosixSignal.SIGTERM, remoteHandle.Process);
  }
  else
  {
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
  }
 
  Assert.True(remoteHandle.Process.WaitForExit(WaitInMS));

src/libraries/Common/src/Interop/Unix/System.Native/Interop.Kill.cs

@@ -1,21 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
 using System.Runtime.InteropServices;
 
 internal static partial class Interop
 {
  internal static partial class Sys
  {
- internal enum Signals : int
- {
- None = 0,
- SIGKILL = 9,
- SIGSTOP = 19
- }
-
  [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_Kill", SetLastError = true)]
- internal static partial int Kill(int pid, Signals signal);
+ internal static partial int Kill(int pid, int signal);
  }
 }

src/libraries/Common/src/Interop/Unix/System.Native/Interop.PosixSignal.cs

@@ -24,5 +24,9 @@ internal static partial class Sys
  [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetPlatformSignalNumber")]
  [SuppressGCTransition]
  internal static partial int GetPlatformSignalNumber(PosixSignal signal);
+
+ [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetPlatformSIGSTOP")]
+ [SuppressGCTransition]
+ internal static partial int GetPlatformSIGSTOP();
  }
 }

src/libraries/System.Diagnostics.Process/ref/System.Diagnostics.Process.cs

@@ -15,6 +15,14 @@ public SafeProcessHandle(System.IntPtr existingHandle, bool ownsHandle) : base (
  [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
  [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
  [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
+ public void Kill() { }
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+ [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
+ public bool Signal(System.Runtime.InteropServices.PosixSignal signal) { throw null; }
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+ [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
  public static Microsoft.Win32.SafeHandles.SafeProcessHandle Start(System.Diagnostics.ProcessStartInfo startInfo) { throw null; }
  }
 }

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.Unix.cs

@@ -59,6 +59,36 @@ protected override bool ReleaseHandle()
  // On Unix, we don't use process descriptors yet, so we can't get PID.
  private static int GetProcessIdCore() => throw new PlatformNotSupportedException();
 
+ private bool SignalCore(PosixSignal signal)
+ {
+ if (ProcessUtils.PlatformDoesNotSupportProcessStartAndKill)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ int signalNumber = Interop.Sys.GetPlatformSignalNumber(signal);
+ if (signalNumber == 0)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ int killResult = Interop.Sys.Kill(ProcessId, signalNumber);
+ if (killResult != 0)
+ {
+ Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
+
+ // Return false if the process has already exited (or never existed).
+ if (errorInfo.Error == Interop.Error.ESRCH)
+ {
+ return false;
+ }
+
+ throw new Win32Exception(errorInfo.RawErrno); // same exception as on Windows
+ }
+
+ return true;
+ }
+
  private delegate SafeProcessHandle StartWithShellExecuteDelegate(ProcessStartInfo startInfo, SafeFileHandle? stdinHandle, SafeFileHandle? stdoutHandle, SafeFileHandle? stderrHandle, out ProcessWaitState.Holder? waitStateHolder);
  private static StartWithShellExecuteDelegate? s_startWithShellExecute;
 

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.Windows.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Security;
@@ -330,5 +331,31 @@ Interop.Shell32.SE_ERR_DDEBUSY or
  }
 
  private int GetProcessIdCore() => Interop.Kernel32.GetProcessId(this);
+
+ private bool SignalCore(PosixSignal signal)
+ {
+ // On Windows, only SIGKILL is supported, mapped to TerminateProcess.
+ if (signal != PosixSignal.SIGKILL)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ if (!Interop.Kernel32.TerminateProcess(this, -1))
+ {
+ int errorCode = Marshal.GetLastWin32Error();
+
+ // Return false if the process has already exited.
+ if (errorCode == Interop.Errors.ERROR_ACCESS_DENIED &&
+ Interop.Kernel32.GetExitCodeProcess(this, out int exitCode) &&
+ exitCode != Interop.Kernel32.HandleOptions.STILL_ACTIVE)
+ {
+ return false;
+ }
+
+ throw new Win32Exception(errorCode);
+ }
+
+ return true;
+ }
  }
 }

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.cs

@@ -11,9 +11,11 @@
 ===========================================================*/
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.Serialization;
 using System.Runtime.Versioning;
+using System.Runtime.InteropServices;
 
 namespace Microsoft.Win32.SafeHandles
 {
@@ -123,6 +125,48 @@ public static SafeProcessHandle Start(ProcessStartInfo startInfo)
  return StartCore(startInfo, childInputHandle, childOutputHandle, childErrorHandle);
  }
 
+ /// <summary>
+ /// Sends a request to the OS to terminate the process.
+ /// </summary>
+ /// <remarks>
+ /// This method does not throw if the process has already exited.
+ /// On Windows, the handle must have <c>PROCESS_TERMINATE</c> access.
+ /// </remarks>
+ /// <exception cref="InvalidOperationException">The handle is invalid.</exception>
+ /// <exception cref="Win32Exception">The process could not be terminated.</exception>
+ [UnsupportedOSPlatform("ios")]
+ [UnsupportedOSPlatform("tvos")]
+ [SupportedOSPlatform("maccatalyst")]
+ public void Kill()
+ {
+ Validate();
+ SignalCore(PosixSignal.SIGKILL);
+ }
+
+ /// <summary>
+ /// Sends a signal to the process.
+ /// </summary>
+ /// <param name="signal">The signal to send.</param>
+ /// <returns>
+ /// <see langword="true"/> if the signal was sent successfully;
+ /// <see langword="false"/> if the process has already exited (or never existed) and the signal was not delivered.
+ /// </returns>
+ /// <remarks>
+ /// On Windows, only <see cref="PosixSignal.SIGKILL"/> is supported and is mapped to <see cref="Kill"/>.
+ /// On Windows, the handle must have <c>PROCESS_TERMINATE</c> access.
+ /// </remarks>
+ /// <exception cref="InvalidOperationException">The handle is invalid.</exception>
+ /// <exception cref="PlatformNotSupportedException">The specified signal is not supported on this platform.</exception>
+ /// <exception cref="Win32Exception">The signal could not be sent.</exception>
+ [UnsupportedOSPlatform("ios")]
+ [UnsupportedOSPlatform("tvos")]
+ [SupportedOSPlatform("maccatalyst")]
+ public bool Signal(PosixSignal signal)
+ {
+ Validate();
+ return SignalCore(signal);
+ }
+
  private void Validate()
  {
  if (IsInvalid)

src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj

@@ -263,6 +263,8 @@
  Link="Common\Interop\Unix\Interop.InitializeTerminalAndSignalHandling.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Kill.cs"
  Link="Common\Interop\Unix\Interop.Kill.cs" />
+ <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.PosixSignal.cs"
+ Link="Common\Interop\Unix\Interop.PosixSignal.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.ReadLink.cs"
  Link="Common\Interop\Unix\Interop.ReadLink.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.RegisterForSigChld.cs"

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs

@@ -69,7 +69,7 @@ public void Kill()
  return;
  }
 
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGKILL);
+ int killResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSignalNumber(PosixSignal.SIGKILL));
  if (killResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();
@@ -105,7 +105,7 @@ private void KillTree(ref List<Exception>? exceptions)
 
  // Stop the process, so it won't start additional children.
  // This is best effort: kill can return before the process is stopped.
- int stopResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGSTOP);
+ int stopResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSIGSTOP());
  if (stopResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();
@@ -119,7 +119,7 @@ private void KillTree(ref List<Exception>? exceptions)
 
  List<Process> children = GetChildProcesses();
 
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGKILL);
+ int killResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSignalNumber(PosixSignal.SIGKILL));
  if (killResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Windows.cs

@@ -93,20 +93,7 @@ public void Kill()
  if (handle.IsInvalid)
  return;
 
- if (!Interop.Kernel32.TerminateProcess(handle, -1))
- {
- // Capture the exception
- var exception = new Win32Exception();
-
- // Don't throw if the process has exited.
- if (exception.NativeErrorCode == Interop.Errors.ERROR_ACCESS_DENIED &&
- Interop.Kernel32.GetExitCodeProcess(handle, out int localExitCode) && localExitCode != Interop.Kernel32.HandleOptions.STILL_ACTIVE)
- {
- return;
- }
-
- throw exception;
- }
+ handle.Kill();
  }
  }
 

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Unix.cs

@@ -27,7 +27,7 @@ public static bool IsProcessRunning(int processId)
  {
  // kill with signal==0 means to not actually send a signal.
  // If we get back 0, the process is still alive.
- int output = Interop.Sys.Kill(processId, Interop.Sys.Signals.None);
+ int output = Interop.Sys.Kill(processId, 0);
  // If kill set errno=EPERM, assume querying process is alive.
  return 0 == output || (-1 == output && Interop.Error.EPERM == Interop.Sys.GetLastError());
  }

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessWaitState.Unix.cs

@@ -351,7 +351,7 @@ private void CheckForNonChildExit()
  bool exited;
  // We won't be able to get an exit code, but we'll at least be able to determine if the process is
  // still running.
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.None); // None means don't send a signal
+ int killResult = Interop.Sys.Kill(_processId, 0); // 0 means don't send a signal, used to check if process is still alive
  if (killResult == 0)
  {
  // Process is still running. This could also be a defunct process that has completed

src/libraries/System.Diagnostics.Process/tests/Interop.cs

@@ -73,6 +73,9 @@ public struct SID_AND_ATTRIBUTES
  }
 
 
+ [DllImport("kernel32.dll", SetLastError = true)]
+ internal static extern SafeProcessHandle OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
+
  [DllImport("kernel32.dll", SetLastError = true)]
  [return: MarshalAs(UnmanagedType.Bool)]
  public static extern bool GenerateConsoleCtrlEvent(uint dwCtrlEvent, uint dwProcessGroupId);

src/libraries/System.Diagnostics.Process/tests/ProcessTests.Unix.cs

@@ -909,18 +909,12 @@ public async Task Kill_ExitedNonChildProcess_DoesNotThrow(bool killTree)
  using (Process nonChildProcess = CreateNonChildProcess())
  {
  // Kill the process.
- int rv = kill(nonChildProcess.Id, SIGKILL);
- Assert.Equal(0, rv);
+ Assert.True(nonChildProcess.SafeHandle.Signal(PosixSignal.SIGKILL));
 
  // Wait until the process is reaped.
- while (rv == 0)
+ while (!nonChildProcess.HasExited)
  {
- rv = kill(nonChildProcess.Id, 0);
- if (rv == 0)
- {
- // process still exists, wait some time.
- await Task.Delay(100);
- }
+ await Task.Delay(100);
 
  DateTime now = DateTime.UtcNow;
  if (start.Ticks + (Helpers.PassingTestTimeoutMilliseconds * 10_000) <= now.Ticks)
@@ -1024,11 +1018,6 @@ private static unsafe HashSet<uint> GetGroups()
  [DllImport("libc")]
  private static extern unsafe int setgroups(int length, uint* groups);
 
- private const int SIGKILL = 9;
-
- [DllImport("libc", SetLastError = true)]
- private static extern int kill(int pid, int sig);
-
  [DllImport("libc", SetLastError = true)]
  private static extern int open(string pathname, int flags);
 
@@ -1062,14 +1051,7 @@ private static string StartAndReadToEnd(string filename, string[] arguments)
  }
  }
 
- private static void SendSignal(PosixSignal signal, int processId)
- {
- int result = kill(processId, Interop.Sys.GetPlatformSignalNumber(signal));
- if (result != 0)
- {
- throw new Win32Exception(Marshal.GetLastWin32Error(), $"Failed to send signal {signal} to process {processId}");
- }
- }
+ private static void SendSignal(PosixSignal signal, Process process) => Assert.True(process.SafeHandle.Signal(signal));
 
  private static unsafe void ReEnableCtrlCHandlerIfNeeded(PosixSignal signal) { }
 
@@ -1115,7 +1097,7 @@ public void ChildProcess_WithParentSignalHandler_CanReceiveSignals()
  AssertRemoteProcessStandardOutputLine(childHandle, ChildReadyMessage, WaitInMS);
 
  // Send SIGCONT to the child process
-SendSignal(PosixSignal.SIGCONT, childHandle.Process.Id);
+Assert.True(childHandle.Process.SafeHandle.Signal(PosixSignal.SIGCONT));
 
  Assert.True(childHandle.Process.WaitForExit(WaitInMS));
  Assert.Equal(RemotelyInvokable.SuccessExitCode, childHandle.Process.ExitCode);

src/libraries/System.Diagnostics.Process/tests/ProcessTests.Windows.cs

@@ -80,7 +80,7 @@ private string WriteScriptFile(string directory, string name, int returnValue)
  return filename;
  }
 
- private static void SendSignal(PosixSignal signal, int processId)
+ private static void SendSignal(PosixSignal signal, Process process)
  {
  uint dwCtrlEvent = signal switch
  {
@@ -89,7 +89,7 @@ private static void SendSignal(PosixSignal signal, int processId)
  _ => throw new ArgumentOutOfRangeException(nameof(signal))
  };
 
- if (!Interop.GenerateConsoleCtrlEvent(dwCtrlEvent, (uint)processId))
+ if (!Interop.GenerateConsoleCtrlEvent(dwCtrlEvent, (uint)process.Id))
  {
  int error = Marshal.GetLastWin32Error();
  if (error == Interop.Errors.ERROR_INVALID_FUNCTION && PlatformDetection.IsInContainer)

src/libraries/System.Diagnostics.Process/tests/ProcessTests.cs

@@ -170,7 +170,7 @@ public void TestCreateNewProcessGroup_HandlerReceivesExpectedSignal(PosixSignal
 
  try
  {
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
 
  Assert.True(remoteHandle.Process.WaitForExit(WaitInMS));
  Assert.Equal(0, remoteHandle.Process.ExitCode);
@@ -243,7 +243,7 @@ public void SignalHandler_CanDisposeInHandler(PosixSignal signal)
  {
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalRegistrationCreatedMessage, WaitInMS);
 
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
 
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalHandlerStartedMessage, WaitInMS);
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalHandlerDisposedMessage, WaitInMS);
@@ -253,11 +253,11 @@ public void SignalHandler_CanDisposeInHandler(PosixSignal signal)
  if (PlatformDetection.IsMonoRuntime && signal == PosixSignal.SIGQUIT && !PlatformDetection.IsWindows)
  {
  // Terminate process using SIGTERM instead.
- SendSignal(PosixSignal.SIGTERM, remoteHandle.Process.Id);
+ SendSignal(PosixSignal.SIGTERM, remoteHandle.Process);
  }
  else
  {
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
  }
 
  Assert.True(remoteHandle.Process.WaitForExit(WaitInMS));

src/libraries/Common/src/Interop/Unix/System.Native/Interop.Kill.cs

@@ -1,21 +1,13 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
 using System.Runtime.InteropServices;
 
 internal static partial class Interop
 {
  internal static partial class Sys
  {
- internal enum Signals : int
- {
- None = 0,
- SIGKILL = 9,
- SIGSTOP = 19
- }
-
  [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_Kill", SetLastError = true)]
- internal static partial int Kill(int pid, Signals signal);
+ internal static partial int Kill(int pid, int signal);
  }
 }

src/libraries/Common/src/Interop/Unix/System.Native/Interop.PosixSignal.cs

@@ -24,5 +24,9 @@ internal static partial class Sys
  [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetPlatformSignalNumber")]
  [SuppressGCTransition]
  internal static partial int GetPlatformSignalNumber(PosixSignal signal);
+
+ [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_GetPlatformSIGSTOP")]
+ [SuppressGCTransition]
+ internal static partial int GetPlatformSIGSTOP();
  }
 }

src/libraries/System.Diagnostics.Process/ref/System.Diagnostics.Process.cs

@@ -15,6 +15,14 @@ public SafeProcessHandle(System.IntPtr existingHandle, bool ownsHandle) : base (
  [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
  [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
  [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
+ public void Kill() { }
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+ [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
+ public bool Signal(System.Runtime.InteropServices.PosixSignal signal) { throw null; }
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+ [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+ [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")]
  public static Microsoft.Win32.SafeHandles.SafeProcessHandle Start(System.Diagnostics.ProcessStartInfo startInfo) { throw null; }
  }
 }

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.Unix.cs

@@ -59,6 +59,36 @@ protected override bool ReleaseHandle()
  // On Unix, we don't use process descriptors yet, so we can't get PID.
  private static int GetProcessIdCore() => throw new PlatformNotSupportedException();
 
+ private bool SignalCore(PosixSignal signal)
+ {
+ if (ProcessUtils.PlatformDoesNotSupportProcessStartAndKill)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ int signalNumber = Interop.Sys.GetPlatformSignalNumber(signal);
+ if (signalNumber == 0)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ int killResult = Interop.Sys.Kill(ProcessId, signalNumber);
+ if (killResult != 0)
+ {
+ Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
+
+ // Return false if the process has already exited (or never existed).
+ if (errorInfo.Error == Interop.Error.ESRCH)
+ {
+ return false;
+ }
+
+ throw new Win32Exception(errorInfo.RawErrno); // same exception as on Windows
+ }
+
+ return true;
+ }
+
  private delegate SafeProcessHandle StartWithShellExecuteDelegate(ProcessStartInfo startInfo, SafeFileHandle? stdinHandle, SafeFileHandle? stdoutHandle, SafeFileHandle? stderrHandle, out ProcessWaitState.Holder? waitStateHolder);
  private static StartWithShellExecuteDelegate? s_startWithShellExecute;
 

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.Windows.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Security;
@@ -330,5 +331,31 @@ Interop.Shell32.SE_ERR_DDEBUSY or
  }
 
  private int GetProcessIdCore() => Interop.Kernel32.GetProcessId(this);
+
+ private bool SignalCore(PosixSignal signal)
+ {
+ // On Windows, only SIGKILL is supported, mapped to TerminateProcess.
+ if (signal != PosixSignal.SIGKILL)
+ {
+ throw new PlatformNotSupportedException();
+ }
+
+ if (!Interop.Kernel32.TerminateProcess(this, -1))
+ {
+ int errorCode = Marshal.GetLastWin32Error();
+
+ // Return false if the process has already exited.
+ if (errorCode == Interop.Errors.ERROR_ACCESS_DENIED &&
+ Interop.Kernel32.GetExitCodeProcess(this, out int exitCode) &&
+ exitCode != Interop.Kernel32.HandleOptions.STILL_ACTIVE)
+ {
+ return false;
+ }
+
+ throw new Win32Exception(errorCode);
+ }
+
+ return true;
+ }
  }
 }

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.cs

@@ -11,9 +11,11 @@
 ===========================================================*/
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.Serialization;
 using System.Runtime.Versioning;
+using System.Runtime.InteropServices;
 
 namespace Microsoft.Win32.SafeHandles
 {
@@ -123,6 +125,48 @@ public static SafeProcessHandle Start(ProcessStartInfo startInfo)
  return StartCore(startInfo, childInputHandle, childOutputHandle, childErrorHandle);
  }
 
+ /// <summary>
+ /// Sends a request to the OS to terminate the process.
+ /// </summary>
+ /// <remarks>
+ /// This method does not throw if the process has already exited.
+ /// On Windows, the handle must have <c>PROCESS_TERMINATE</c> access.
+ /// </remarks>
+ /// <exception cref="InvalidOperationException">The handle is invalid.</exception>
+ /// <exception cref="Win32Exception">The process could not be terminated.</exception>
+ [UnsupportedOSPlatform("ios")]
+ [UnsupportedOSPlatform("tvos")]
+ [SupportedOSPlatform("maccatalyst")]
+ public void Kill()
+ {
+ Validate();
+ SignalCore(PosixSignal.SIGKILL);
+ }
+
+ /// <summary>
+ /// Sends a signal to the process.
+ /// </summary>
+ /// <param name="signal">The signal to send.</param>
+ /// <returns>
+ /// <see langword="true"/> if the signal was sent successfully;
+ /// <see langword="false"/> if the process has already exited (or never existed) and the signal was not delivered.
+ /// </returns>
+ /// <remarks>
+ /// On Windows, only <see cref="PosixSignal.SIGKILL"/> is supported and is mapped to <see cref="Kill"/>.
+ /// On Windows, the handle must have <c>PROCESS_TERMINATE</c> access.
+ /// </remarks>
+ /// <exception cref="InvalidOperationException">The handle is invalid.</exception>
+ /// <exception cref="PlatformNotSupportedException">The specified signal is not supported on this platform.</exception>
+ /// <exception cref="Win32Exception">The signal could not be sent.</exception>
+ [UnsupportedOSPlatform("ios")]
+ [UnsupportedOSPlatform("tvos")]
+ [SupportedOSPlatform("maccatalyst")]
+ public bool Signal(PosixSignal signal)
+ {
+ Validate();
+ return SignalCore(signal);
+ }
+
  private void Validate()
  {
  if (IsInvalid)

src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj

@@ -263,6 +263,8 @@
  Link="Common\Interop\Unix\Interop.InitializeTerminalAndSignalHandling.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Kill.cs"
  Link="Common\Interop\Unix\Interop.Kill.cs" />
+ <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.PosixSignal.cs"
+ Link="Common\Interop\Unix\Interop.PosixSignal.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.ReadLink.cs"
  Link="Common\Interop\Unix\Interop.ReadLink.cs" />
  <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.RegisterForSigChld.cs"

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs

@@ -69,7 +69,7 @@ public void Kill()
  return;
  }
 
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGKILL);
+ int killResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSignalNumber(PosixSignal.SIGKILL));
  if (killResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();
@@ -105,7 +105,7 @@ private void KillTree(ref List<Exception>? exceptions)
 
  // Stop the process, so it won't start additional children.
  // This is best effort: kill can return before the process is stopped.
- int stopResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGSTOP);
+ int stopResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSIGSTOP());
  if (stopResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();
@@ -119,7 +119,7 @@ private void KillTree(ref List<Exception>? exceptions)
 
  List<Process> children = GetChildProcesses();
 
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.SIGKILL);
+ int killResult = Interop.Sys.Kill(_processId, Interop.Sys.GetPlatformSignalNumber(PosixSignal.SIGKILL));
  if (killResult != 0)
  {
  Interop.Error error = Interop.Sys.GetLastError();

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Windows.cs

@@ -93,20 +93,7 @@ public void Kill()
  if (handle.IsInvalid)
  return;
 
- if (!Interop.Kernel32.TerminateProcess(handle, -1))
- {
- // Capture the exception
- var exception = new Win32Exception();
-
- // Don't throw if the process has exited.
- if (exception.NativeErrorCode == Interop.Errors.ERROR_ACCESS_DENIED &&
- Interop.Kernel32.GetExitCodeProcess(handle, out int localExitCode) && localExitCode != Interop.Kernel32.HandleOptions.STILL_ACTIVE)
- {
- return;
- }
-
- throw exception;
- }
+ handle.Kill();
  }
  }
 

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Unix.cs

@@ -27,7 +27,7 @@ public static bool IsProcessRunning(int processId)
  {
  // kill with signal==0 means to not actually send a signal.
  // If we get back 0, the process is still alive.
- int output = Interop.Sys.Kill(processId, Interop.Sys.Signals.None);
+ int output = Interop.Sys.Kill(processId, 0);
  // If kill set errno=EPERM, assume querying process is alive.
  return 0 == output || (-1 == output && Interop.Error.EPERM == Interop.Sys.GetLastError());
  }

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/ProcessWaitState.Unix.cs

@@ -351,7 +351,7 @@ private void CheckForNonChildExit()
  bool exited;
  // We won't be able to get an exit code, but we'll at least be able to determine if the process is
  // still running.
- int killResult = Interop.Sys.Kill(_processId, Interop.Sys.Signals.None); // None means don't send a signal
+ int killResult = Interop.Sys.Kill(_processId, 0); // 0 means don't send a signal, used to check if process is still alive
  if (killResult == 0)
  {
  // Process is still running. This could also be a defunct process that has completed

src/libraries/System.Diagnostics.Process/tests/Interop.cs

@@ -73,6 +73,9 @@ public struct SID_AND_ATTRIBUTES
  }
 
 
+ [DllImport("kernel32.dll", SetLastError = true)]
+ internal static extern SafeProcessHandle OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
+
  [DllImport("kernel32.dll", SetLastError = true)]
  [return: MarshalAs(UnmanagedType.Bool)]
  public static extern bool GenerateConsoleCtrlEvent(uint dwCtrlEvent, uint dwProcessGroupId);

src/libraries/System.Diagnostics.Process/tests/ProcessTests.Unix.cs

@@ -909,18 +909,12 @@ public async Task Kill_ExitedNonChildProcess_DoesNotThrow(bool killTree)
  using (Process nonChildProcess = CreateNonChildProcess())
  {
  // Kill the process.
- int rv = kill(nonChildProcess.Id, SIGKILL);
- Assert.Equal(0, rv);
+ Assert.True(nonChildProcess.SafeHandle.Signal(PosixSignal.SIGKILL));
 
  // Wait until the process is reaped.
- while (rv == 0)
+ while (!nonChildProcess.HasExited)
  {
- rv = kill(nonChildProcess.Id, 0);
- if (rv == 0)
- {
- // process still exists, wait some time.
- await Task.Delay(100);
- }
+ await Task.Delay(100);
 
  DateTime now = DateTime.UtcNow;
  if (start.Ticks + (Helpers.PassingTestTimeoutMilliseconds * 10_000) <= now.Ticks)
@@ -1024,11 +1018,6 @@ private static unsafe HashSet<uint> GetGroups()
  [DllImport("libc")]
  private static extern unsafe int setgroups(int length, uint* groups);
 
- private const int SIGKILL = 9;
-
- [DllImport("libc", SetLastError = true)]
- private static extern int kill(int pid, int sig);
-
  [DllImport("libc", SetLastError = true)]
  private static extern int open(string pathname, int flags);
 
@@ -1062,14 +1051,7 @@ private static string StartAndReadToEnd(string filename, string[] arguments)
  }
  }
 
- private static void SendSignal(PosixSignal signal, int processId)
- {
- int result = kill(processId, Interop.Sys.GetPlatformSignalNumber(signal));
- if (result != 0)
- {
- throw new Win32Exception(Marshal.GetLastWin32Error(), $"Failed to send signal {signal} to process {processId}");
- }
- }
+ private static void SendSignal(PosixSignal signal, Process process) => Assert.True(process.SafeHandle.Signal(signal));
 
  private static unsafe void ReEnableCtrlCHandlerIfNeeded(PosixSignal signal) { }
 
@@ -1115,7 +1097,7 @@ public void ChildProcess_WithParentSignalHandler_CanReceiveSignals()
  AssertRemoteProcessStandardOutputLine(childHandle, ChildReadyMessage, WaitInMS);
 
  // Send SIGCONT to the child process
-SendSignal(PosixSignal.SIGCONT, childHandle.Process.Id);
+Assert.True(childHandle.Process.SafeHandle.Signal(PosixSignal.SIGCONT));
 
  Assert.True(childHandle.Process.WaitForExit(WaitInMS));
  Assert.Equal(RemotelyInvokable.SuccessExitCode, childHandle.Process.ExitCode);

src/libraries/System.Diagnostics.Process/tests/ProcessTests.Windows.cs

@@ -80,7 +80,7 @@ private string WriteScriptFile(string directory, string name, int returnValue)
  return filename;
  }
 
- private static void SendSignal(PosixSignal signal, int processId)
+ private static void SendSignal(PosixSignal signal, Process process)
  {
  uint dwCtrlEvent = signal switch
  {
@@ -89,7 +89,7 @@ private static void SendSignal(PosixSignal signal, int processId)
  _ => throw new ArgumentOutOfRangeException(nameof(signal))
  };
 
- if (!Interop.GenerateConsoleCtrlEvent(dwCtrlEvent, (uint)processId))
+ if (!Interop.GenerateConsoleCtrlEvent(dwCtrlEvent, (uint)process.Id))
  {
  int error = Marshal.GetLastWin32Error();
  if (error == Interop.Errors.ERROR_INVALID_FUNCTION && PlatformDetection.IsInContainer)

src/libraries/System.Diagnostics.Process/tests/ProcessTests.cs

@@ -170,7 +170,7 @@ public void TestCreateNewProcessGroup_HandlerReceivesExpectedSignal(PosixSignal
 
  try
  {
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
 
  Assert.True(remoteHandle.Process.WaitForExit(WaitInMS));
  Assert.Equal(0, remoteHandle.Process.ExitCode);
@@ -243,7 +243,7 @@ public void SignalHandler_CanDisposeInHandler(PosixSignal signal)
  {
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalRegistrationCreatedMessage, WaitInMS);
 
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
 
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalHandlerStartedMessage, WaitInMS);
  AssertRemoteProcessStandardOutputLine(remoteHandle, PosixSignalHandlerDisposedMessage, WaitInMS);
@@ -253,11 +253,11 @@ public void SignalHandler_CanDisposeInHandler(PosixSignal signal)
  if (PlatformDetection.IsMonoRuntime && signal == PosixSignal.SIGQUIT && !PlatformDetection.IsWindows)
  {
  // Terminate process using SIGTERM instead.
- SendSignal(PosixSignal.SIGTERM, remoteHandle.Process.Id);
+ SendSignal(PosixSignal.SIGTERM, remoteHandle.Process);
  }
  else
  {
- SendSignal(signal, remoteHandle.Process.Id);
+ SendSignal(signal, remoteHandle.Process);
  }
 
  Assert.True(remoteHandle.Process.WaitForExit(WaitInMS));