Add new process management APIs to SafeProcessHandle

src/libraries/Common/src/Interop/Windows/Advapi32/Interop.ProcessOptions.cs

@@ -44,6 +44,7 @@ internal static partial class StartupInfoOptions
             internal const int CREATE_UNICODE_ENVIRONMENT = 0x00000400;
             internal const int CREATE_NO_WINDOW = 0x08000000;
             internal const int CREATE_NEW_PROCESS_GROUP = 0x00000200;
+            internal const int CREATE_SUSPENDED = 0x00000004;
         }
     }
 }

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.SetConsoleCtrlHandler.cs → src/libraries/Common/src/Interop/Windows/Kernel32/Interop.ConsoleCtrl.cs

@@ -16,5 +16,9 @@ internal static partial class Kernel32
         [LibraryImport(Libraries.Kernel32, SetLastError = true)]
         [return: MarshalAs(UnmanagedType.Bool)]
         internal static unsafe partial bool SetConsoleCtrlHandler(delegate* unmanaged<int, BOOL> handler, [MarshalAs(UnmanagedType.Bool)] bool Add);
+
+        [LibraryImport(Libraries.Kernel32, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static partial bool GenerateConsoleCtrlEvent(int dwCtrlEvent, int dwProcessGroupId);
     }
 }

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.HandleInformation.cs

@@ -20,5 +20,13 @@ internal enum HandleFlags : uint
         [LibraryImport(Libraries.Kernel32, SetLastError = true)]
         [return: MarshalAs(UnmanagedType.Bool)]
         internal static partial bool SetHandleInformation(SafeHandle hObject, HandleFlags dwMask, HandleFlags dwFlags);
+
+        [LibraryImport(Libraries.Kernel32, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static partial bool GetHandleInformation(IntPtr hObject, out int lpdwFlags);
+
+        [LibraryImport(Libraries.Kernel32, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static partial bool SetHandleInformation(IntPtr hObject, int dwMask, int dwFlags);
     }
 }

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.HandleOptions.cs

@@ -10,6 +10,7 @@ internal static partial class HandleOptions
             internal const int DUPLICATE_SAME_ACCESS = 2;
             internal const int STILL_ACTIVE = 0x00000103;
             internal const int TOKEN_ADJUST_PRIVILEGES = 0x20;
+            internal const int HANDLE_FLAG_INHERIT = 0x00000001;
         }
     }
 }

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.JobObjects.cs

@@ -0,0 +1,66 @@
+// 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 Kernel32
+    {
+        [LibraryImport(Libraries.Kernel32, SetLastError = true)]
+        internal static partial IntPtr CreateJobObjectW(IntPtr lpJobAttributes, IntPtr lpName);
+
+        internal const uint JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x00002000;
+
+        internal enum JOBOBJECTINFOCLASS
+        {
+            JobObjectBasicLimitInformation = 2,
+            JobObjectExtendedLimitInformation = 9
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct IO_COUNTERS
+        {
+            internal ulong ReadOperationCount;
+            internal ulong WriteOperationCount;
+            internal ulong OtherOperationCount;
+            internal ulong ReadTransferCount;
+            internal ulong WriteTransferCount;
+            internal ulong OtherTransferCount;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct JOBOBJECT_BASIC_LIMIT_INFORMATION
+        {
+            internal long PerProcessUserTimeLimit;
+            internal long PerJobUserTimeLimit;
+            internal uint LimitFlags;
+            internal UIntPtr MinimumWorkingSetSize;
+            internal UIntPtr MaximumWorkingSetSize;
+            internal uint ActiveProcessLimit;
+            internal UIntPtr Affinity;
+            internal uint PriorityClass;
+            internal uint SchedulingClass;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION
+        {
+            internal JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
+            internal IO_COUNTERS IoInfo;
+            internal UIntPtr ProcessMemoryLimit;
+            internal UIntPtr JobMemoryLimit;
+            internal UIntPtr PeakProcessMemoryUsed;
+            internal UIntPtr PeakJobMemoryUsed;
+        }
+
+        [LibraryImport(Libraries.Kernel32, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static partial bool SetInformationJobObject(IntPtr hJob, JOBOBJECTINFOCLASS JobObjectInfoClass, ref JOBOBJECT_EXTENDED_LIMIT_INFORMATION lpJobObjectInfo, uint cbJobObjectInfoLength);
+
+        [LibraryImport(Libraries.Kernel32, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static partial bool TerminateJobObject(IntPtr hJob, uint uExitCode);
+    }
+}

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.ProcThreadAttributeList.cs

@@ -0,0 +1,64 @@
+// 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 Kernel32
+    {
+        internal const int PROC_THREAD_ATTRIBUTE_HANDLE_LIST = 0x00020002;
+        internal const int PROC_THREAD_ATTRIBUTE_JOB_LIST = 0x0002000D;
+        internal const int EXTENDED_STARTUPINFO_PRESENT = 0x00080000;
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct STARTUPINFOEX
+        {
+            internal STARTUPINFO StartupInfo;
+            internal LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList;
+        }
+
+        internal struct LPPROC_THREAD_ATTRIBUTE_LIST
+        {
+            internal IntPtr AttributeList;
+        }
+
+        [LibraryImport(Libraries.Kernel32, EntryPoint = "CreateProcessW", SetLastError = true, StringMarshalling = StringMarshalling.Utf16)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static unsafe partial bool CreateProcess(
+            char* lpApplicationName,
+            char* lpCommandLine,
+            ref SECURITY_ATTRIBUTES procSecAttrs,
+            ref SECURITY_ATTRIBUTES threadSecAttrs,
+            [MarshalAs(UnmanagedType.Bool)] bool bInheritHandles,
+            int dwCreationFlags,
+            char* lpEnvironment,
+            string? lpCurrentDirectory,
+            ref STARTUPINFOEX lpStartupInfo,
+            ref PROCESS_INFORMATION lpProcessInformation
+        );
+
+        [LibraryImport(Libraries.Kernel32, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static unsafe partial bool InitializeProcThreadAttributeList(
+            LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList,
+            int dwAttributeCount,
+            int dwFlags,
+            ref IntPtr lpSize);
+
+        [LibraryImport(Libraries.Kernel32, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static unsafe partial bool UpdateProcThreadAttribute(
+            LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList,
+            int dwFlags,
+            IntPtr attribute,
+            void* lpValue,
+            IntPtr cbSize,
+            void* lpPreviousValue,
+            IntPtr lpReturnSize);
+
+        [LibraryImport(Libraries.Kernel32, SetLastError = true)]
+        internal static unsafe partial void DeleteProcThreadAttributeList(LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList);
+    }
+}

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.ResumeThread_IntPtr.cs

@@ -0,0 +1,14 @@
+// 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 Kernel32
+    {
+        [LibraryImport(Libraries.Kernel32, SetLastError = true)]
+        internal static partial int ResumeThread(IntPtr hThread);
+    }
+}

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

@@ -10,7 +10,21 @@ public sealed partial class SafeProcessHandle : Microsoft.Win32.SafeHandles.Safe
     {
         public SafeProcessHandle() : base (default(bool)) { }
         public SafeProcessHandle(System.IntPtr existingHandle, bool ownsHandle) : base (default(bool)) { }
+        public int ProcessId { get { throw null; } }
+        public bool Kill() { throw null; }
+        public bool KillProcessGroup() { throw null; }
+        public static Microsoft.Win32.SafeHandles.SafeProcessHandle Open(int processId) { throw null; }
         protected override bool ReleaseHandle() { throw null; }
+        public void Resume() { }
+        public void Signal(System.Runtime.InteropServices.PosixSignal signal) { }
+        public void SignalProcessGroup(System.Runtime.InteropServices.PosixSignal signal) { }
+        public static Microsoft.Win32.SafeHandles.SafeProcessHandle Start(System.Diagnostics.ProcessStartOptions options, Microsoft.Win32.SafeHandles.SafeFileHandle? input, Microsoft.Win32.SafeHandles.SafeFileHandle? output, Microsoft.Win32.SafeHandles.SafeFileHandle? error) { throw null; }
+        public static Microsoft.Win32.SafeHandles.SafeProcessHandle StartSuspended(System.Diagnostics.ProcessStartOptions options, Microsoft.Win32.SafeHandles.SafeFileHandle? input, Microsoft.Win32.SafeHandles.SafeFileHandle? output, Microsoft.Win32.SafeHandles.SafeFileHandle? error) { throw null; }
+        public bool TryWaitForExit(System.TimeSpan timeout, [System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out System.Diagnostics.ProcessExitStatus? exitStatus) { throw null; }
+        public System.Diagnostics.ProcessExitStatus WaitForExit() { throw null; }
+        public System.Threading.Tasks.Task<System.Diagnostics.ProcessExitStatus> WaitForExitAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public System.Threading.Tasks.Task<System.Diagnostics.ProcessExitStatus> WaitForExitOrKillOnCancellationAsync(System.Threading.CancellationToken cancellationToken) { throw null; }
+        public System.Diagnostics.ProcessExitStatus WaitForExitOrKillOnTimeout(System.TimeSpan timeout) { throw null; }
     }
 }
 namespace System.Diagnostics

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

@@ -1,17 +1,14 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-/*============================================================
-**
-** Class:  SafeProcessHandle
-**
-** A wrapper for a process handle
-**
-**
-===========================================================*/
-
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Microsoft.Win32.SafeHandles
 {
@@ -35,16 +32,34 @@ internal SafeProcessHandle(int processId, SafeWaitHandle handle) :
             handle.DangerousAddRef(ref _releaseRef);
         }
 
-        internal int ProcessId { get; }
-
         protected override bool ReleaseHandle()
         {
             if (_releaseRef)
             {
-                Debug.Assert(_handle != null);
+                Debug.Assert(_handle is not null);
                 _handle.DangerousRelease();
             }
             return true;
         }
+
+        private static SafeProcessHandle OpenCore(int processId) => throw new NotImplementedException();
+
+        private static SafeProcessHandle StartCore(ProcessStartOptions options, SafeFileHandle inputHandle, SafeFileHandle outputHandle, SafeFileHandle errorHandle, bool createSuspended) => throw new NotImplementedException();
+
+        private ProcessExitStatus WaitForExitCore() => throw new NotImplementedException();
+
+        private bool TryWaitForExitCore(int milliseconds, [NotNullWhen(true)] out ProcessExitStatus? exitStatus) => throw new NotImplementedException();
+
+        private ProcessExitStatus WaitForExitOrKillOnTimeoutCore(int milliseconds) => throw new NotImplementedException();
+
+        private Task<ProcessExitStatus> WaitForExitAsyncCore(CancellationToken cancellationToken) => throw new NotImplementedException();
+
+        private Task<ProcessExitStatus> WaitForExitOrKillOnCancellationAsyncCore(CancellationToken cancellationToken) => throw new NotImplementedException();
+
+        internal bool KillCore(bool throwOnError, bool entireProcessGroup = false) => throw new NotImplementedException();
+
+        private void ResumeCore() => throw new NotImplementedException();
+
+        private void SendSignalCore(PosixSignal signal, bool entireProcessGroup) => throw new NotImplementedException();
     }
 }