[cDAC] Implement GetPartialUserState for cDAC

[barosiak]

Summary

Replaces the legacy-delegation stub in DacDbiImpl.GetPartialUserState with a managed implementation using the IThread contract, mirroring the native C++ logic in dacdbiimpl.cpp that maps thread state flags to CorDebugUserState.

Changes

• Add Interruptible to ThreadState enum (from m_State)
• Add new ThreadStateNC enum and StateNC field (from m_StateNC)
• Implement GetPartialUserState in DacDbiImpl with DEBUG cross-validation
• Add CorDebugUserState typed enum to IDacDbiInterface
• Update data descriptor, contract docs, and VM annotations
• Add unit and dump tests

[dotnet-policy-service]

Tagging subscribers to this area: @steveisok, @tommcdon, @dotnet/dotnet-diag
See info in area-owners.md if you want to be subscribed.

[Copilot]

Pull request overview

Implements DacDbiImpl.GetPartialUserState in the managed cDAC reader by mapping thread state flags from the IThread contract (including new Interruptible and StateNC/ThreadStateNC) to a typed CorDebugUserState, and adds unit + dump-based tests to validate the mapping.

Changes:

• Extend the Thread contract surface to expose Interruptible plus a new StateNC field (ThreadStateNC) and plumb it through descriptors, data model, and contract implementation.
• Replace the legacy-delegation stub for GetPartialUserState with a managed implementation (plus DEBUG cross-validation against legacy DAC).
• Add unit and dump tests validating state-flag mapping and GetPartialUserState results.

Reviewed changes

Copilot reviewed 12 out of 12 changed files in this pull request and generated 2 comments.

Show a summary per file

File	Description
src/native/managed/cdac/tests/ThreadTests.cs	Adds a unit test ensuring raw state fields map to ThreadState / ThreadStateNC.
src/native/managed/cdac/tests/MockDescriptors/MockDescriptors.Thread.cs	Extends mock Thread layout to include StateNC and exposes setters.
src/native/managed/cdac/tests/DumpTests/DacDbi/DacDbiThreadDumpTests.cs	Adds dump test cross-validating GetPartialUserState against IThread contract data.
src/native/managed/cdac/tests/ClrDataExceptionStateTests.cs	Updates mocks constructing ThreadData to include the new StateNC field.
src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/Dbi/IDacDbiInterface.cs	Introduces typed CorDebugUserState and updates GetPartialUserState signature.
src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Legacy/Dbi/DacDbiImpl.cs	Implements GetPartialUserState using thread contract data and DEBUG cross-validation.
src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Data/Thread.cs	Reads new StateNC field from the Thread data descriptor.
src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/Thread_1.cs	Maps StateNC into ThreadData and adds Interruptible mapping.
src/native/managed/cdac/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/IThread.cs	Extends ThreadState, adds ThreadStateNC, and adds StateNC to ThreadData.
src/coreclr/vm/threads.h	Annotates thread state bits and adds m_StateNC to the cDAC data offsets.
src/coreclr/vm/datadescriptor/datadescriptor.inc	Adds Thread.StateNC field to the cDAC data descriptor.
docs/design/datacontracts/Thread.md	Documents new ThreadState.Interruptible, ThreadStateNC, and ThreadData.StateNC.

[jkotas]

Do we really need this flag?

These flags seem to be always set together:

runtime/src/coreclr/vm/comsynchronizable.cpp

Lines 438 to 454 in 1f84bc9

	// Set the state bits.
	thread->SetThreadState(Thread::TS_Interruptible);
	thread->SetThreadStateNC(Thread::TSNC_DebuggerSleepWaitJoin);
	}
	extern "C" void QCALLTYPE ThreadNative_ClearWaitSleepJoinState(QCall::ThreadHandle thread)
	{
	CONTRACTL
	{
	QCALL_CHECK_NO_GC_TRANSITION;
	PRECONDITION(thread != NULL);
	}
	CONTRACTL_END;
	// Clear the state bits.
	thread->ResetThreadState(Thread::TS_Interruptible);
	thread->ResetThreadStateNC(Thread::TSNC_DebuggerSleepWaitJoin);

. The comment that say

runtime/src/coreclr/vm/threads.cpp

Line 4466 in 1f84bc9

ResetThreadState ((ThreadState)(TS_Interrupted | TS_Interruptible));

is one place where we clear TS_Interruptible, but leave TSNC_DebuggerSleepWaitJoin set. That looks like a bug.

I would suggest we delete TSNC_DebuggerSleepWaitJoin and just depend on TS_Interruptible

[max-charlamb]

@jkoritzinsky, Do you have any more context on why we have these separated? It looks like you modified this relatively recently in #117788

There is some old comment about this being used to address a race condition.

runtime/src/coreclr/debug/daccess/dacdbiimpl.cpp

Lines 5694 to 5703 in 4da638d

	// Don't report Thread::TS_AbortRequested
	// The interruptible flag is unreliable (see issue 699245)
	// The Debugger_SleepWaitJoin is always accurate when it is present, but it is still
	// just a band-aid fix to cover some of the race conditions interruptible has.
	if (ts & Thread::TS_Interruptible || pThread->HasThreadStateNC(Thread::TSNC_DebuggerSleepWaitJoin))
	{
	result |= USER_WAIT_SLEEP_JOIN;
	}

[jkotas]

Historically, the managed threading APIs had deep roots into the rest of the runtime. I think this is left-over of that. We have been working on untangling it for a while now.

The core (unmanaged) runtime does not actually care about the SleepWaitJoin state at all. This state just tracks whether you are inside Thread.Sleep or one of the managed Wait APIs. It would be perfectly fine to move this bit to the managed Thread (like it is done in Native AOT). I am not asking for that to be done as part of this PR- I am just trying to explain what this state really is.

[jkotas]

We should rename this to TS_WaitSleepJoin since that's what the same thing is called in public APIs: https://learn.microsoft.com/en-us/dotnet/api/system.threading.threadstate