Implement SafeProcessHandle.Start

@stephentoub

The API got re-approved in New Process APIs #125838 (comment)
We can just move Process.StartCore to SafeProcessHandle.Start.
We should consider using process file descriptors when available on Unix (modern Linux and FreeBSD as long as FreeBSD does nto kill processes on close). But this may require braking changes due to SafeWaitHandle role in SafeProcessHandle.Unix.cs

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

Lines 20 to 48 in 44cd131

    
           // On Windows, SafeProcessHandle represents the actual OS handle for the process. 
        
           // On Unix, there's no such concept.  Instead, the implementation manufactures 
        
           // a WaitHandle that it manually sets when the process completes; SafeProcessHandle 
        
           // then just wraps that same WaitHandle instance.  This allows consumers that use 
        
           // Process.{Safe}Handle to initialize and use a WaitHandle to successfully use it on 
        
           // Unix as well to wait for the process to complete. 
        
           private readonly SafeWaitHandle? _handle; 
        
           private readonly bool _releaseRef; 
        
           internal SafeProcessHandle(int processId, SafeWaitHandle handle) : 
        
               this(handle.DangerousGetHandle(), ownsHandle: true) 
        
           { 
        
               ProcessId = processId; 
        
               _handle = handle; 
        
               handle.DangerousAddRef(ref _releaseRef); 
        
           } 
        
           internal int ProcessId { get; } 
        
           protected override bool ReleaseHandle() 
        
           { 
        
               if (_releaseRef) 
        
               { 
        
                   Debug.Assert(_handle != null); 
        
                   _handle.DangerousRelease(); 
        
               } 
        
               return true; 
        
           }

It allows to create a SafeWaitHandle out of SafeProcessHandle.handle:

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

Line 1308 in 44cd131

    
           mre.SetSafeWaitHandle(new SafeWaitHandle(useSafeHandle ? h.Process.SafeHandle.DangerousGetHandle() : h.Process.Handle, ownsHandle: false));

More context: dotnet/corefx#36199, #28773

cc @stephentoub (I don't have a solution right now, just letting you know that the handle could become a real handle on Linux and FreeBSD)

Tagging subscribers to this area: @dotnet/area-system-diagnostics-process
See info in area-owners.md if you want to be subscribed.

I don't have a solution right now

Thinking out loud: I need to explore what it would take to simply return pidf from the SafeProcessHandle.DangerousGetHandle and get SafeWaitHandle to work with such input on Unix. It's a pollable descriptor, so it should be able to get it to work.

SafeProcessHandle.DangerousGetHandle and get SafeWaitHandle to work with such input on Unix. It's a pollable descriptor, so it should be able to get it to work.

I do not see how it can work. SafeWaitHandle on non-Windows is our own simulator of Windows OS wait handles semantics. It does not interop with OS provided poll, etc.

Introduce SafeProcessHandle.Start and ProcessId (#126192)

Navigation Menu

Repository navigation

Implement SafeProcessHandle.Start #126107

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

	// On Windows, SafeProcessHandle represents the actual OS handle for the process.
	// On Unix, there's no such concept. Instead, the implementation manufactures
	// a WaitHandle that it manually sets when the process completes; SafeProcessHandle
	// then just wraps that same WaitHandle instance. This allows consumers that use
	// Process.{Safe}Handle to initialize and use a WaitHandle to successfully use it on
	// Unix as well to wait for the process to complete.

	private readonly SafeWaitHandle? _handle;
	private readonly bool _releaseRef;

	internal SafeProcessHandle(int processId, SafeWaitHandle handle) :
	this(handle.DangerousGetHandle(), ownsHandle: true)
	{
	ProcessId = processId;
	_handle = handle;
	handle.DangerousAddRef(ref _releaseRef);
	}

	internal int ProcessId { get; }

	protected override bool ReleaseHandle()
	{
	if (_releaseRef)
	{
	Debug.Assert(_handle != null);
	_handle.DangerousRelease();
	}
	return true;
	}

Implement SafeProcessHandle.Start #126107

Description

Activity

dotnet-policy-service commented on Mar 25, 2026

adamsitnik commented on Mar 26, 2026

jkotas commented on Mar 26, 2026

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions