Fix AsyncInstrumentation to honor s_asyncDebuggingEnabled by tommcdon · Pull Request #127233 · dotnet/runtime

tommcdon · 2026-04-21T17:58:52Z

When the debugger sets Task.s_asyncDebuggingEnabled directly via ICorDebug (SetManagedTaskEtwEventsEnabled), the AsyncInstrumentation flags system added by PR #126091 was not aware of this. The new flags only got set via ETW OnEventCommand, so non-ETW RuntimeAsync configs had s_asyncDebuggerActiveFlags stuck at Disabled, preventing NotifyDebuggerOfRuntimeAsyncState from being called.

Fix: In InitializeFlags(), check Task.s_asyncDebuggingEnabled as a fallback when s_asyncDebuggerActiveFlags is still Disabled. This ensures the debugger's request is honored regardless of whether ETW events have been enabled.

…rDebug When the debugger sets Task.s_asyncDebuggingEnabled directly via ICorDebug (SetManagedTaskEtwEventsEnabled), the AsyncInstrumentation flags system added by PR dotnet#126091 was not aware of this. The new flags only got set via ETW OnEventCommand, so non-ETW RuntimeAsync configs had s_asyncDebuggerActiveFlags stuck at Disabled, preventing NotifyDebuggerOfRuntimeAsyncState from being called. Fix: In InitializeFlags(), check Task.s_asyncDebuggingEnabled as a fallback when s_asyncDebuggerActiveFlags is still Disabled. This ensures the debugger's request is honored regardless of whether ETW events have been enabled. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

dotnet-policy-service · 2026-04-21T18:01:03Z

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

This PR updates CoreLib’s AsyncInstrumentation initialization so RuntimeAsync debugging instrumentation is enabled when the debugger toggles Task.s_asyncDebuggingEnabled directly (e.g., via ICorDebug) even if no ETW session ever triggers TplEventSource.OnEventCommand.

Changes:

In AsyncInstrumentation.InitializeFlags(), if debugger flags are still Disabled but Task.s_asyncDebuggingEnabled is true, enable DefaultFlags | Flags.AsyncDebugger as a fallback.
Preserve the existing ETW-driven flag update path (the fallback only applies when s_asyncDebuggerActiveFlags is still Disabled).

Copilot · 2026-04-21T18:03:36Z

+ // The debugger may have set Task.s_asyncDebuggingEnabled directly via ICorDebug
+ // before any ETW session is established. In that case, s_asyncDebuggerActiveFlags
+ // will still be Disabled because OnEventCommand was never called. Honor the
+ // debugger's request by enabling default flags when s_asyncDebuggingEnabled is set.
+ if (s_asyncDebuggerActiveFlags == Flags.Disabled && Task.s_asyncDebuggingEnabled)
+ {
+ s_asyncDebuggerActiveFlags = DefaultFlags | Flags.AsyncDebugger;
+ }


This new fallback behavior (enabling AsyncInstrumentation when only Task.s_asyncDebuggingEnabled is set, without an ETW session) doesn’t appear to be covered by existing runtime-async tests. Consider adding a test that sets Task.s_asyncDebuggingEnabled via reflection without creating a TplEventSource listener, then triggers flag initialization (e.g., via a RuntimeAsyncMethodGeneration async method) and asserts AsyncInstrumentation.s_activeFlags becomes enabled (and that the relevant runtime-async collections are initialized as expected).

Copilot · 2026-04-21T18:03:37Z

+ if (s_asyncDebuggerActiveFlags == Flags.Disabled && Task.s_asyncDebuggingEnabled)
+ {
+ s_asyncDebuggerActiveFlags = DefaultFlags | Flags.AsyncDebugger;
+ }


With this change, if Task.s_asyncDebuggingEnabled is later cleared (e.g., debugger detach) in a non-ETW scenario where OnEventCommand never calls UpdateAsyncDebuggerFlags(Disabled), s_asyncDebuggerActiveFlags/s_activeFlags will remain non-Disabled and keep routing RuntimeAsyncTask through the instrumented path (even though AsyncDebugger hooks will be gated by Task.s_asyncDebuggingEnabled). If detach/toggling is expected to work without ETW, consider adding a corresponding “disable” path (e.g., re-check Task.s_asyncDebuggingEnabled in SyncActiveFlags/InstrumentCheckPoint or another explicit update mechanism).

lateralusX · 2026-04-21T19:31:03Z

Let's fix this at debugger side, debugger can set the debugger flag directly in s_asyncDebuggerActiveFlags as done in this fix and it will get picked up when flags initialize synchronize in first async method running through the dispatch continuations loop. Once set o the debugger side we can drop the use of s_asyncDebuggingEnabled inside the asyncv2 instrumentation paths.

lateralusX · 2026-04-23T13:34:47Z

#127238 implements the solution for this.

tommcdon · 2026-04-21T17:58:52Z

When the debugger sets Task.s_asyncDebuggingEnabled directly via ICorDebug (SetManagedTaskEtwEventsEnabled), the AsyncInstrumentation flags system added by PR #126091 was not aware of this. The new flags only got set via ETW OnEventCommand, so non-ETW RuntimeAsync configs had s_asyncDebuggerActiveFlags stuck at Disabled, preventing NotifyDebuggerOfRuntimeAsyncState from being called.

Fix: In InitializeFlags(), check Task.s_asyncDebuggingEnabled as a fallback when s_asyncDebuggerActiveFlags is still Disabled. This ensures the debugger's request is honored regardless of whether ETW events have been enabled.

…rDebug When the debugger sets Task.s_asyncDebuggingEnabled directly via ICorDebug (SetManagedTaskEtwEventsEnabled), the AsyncInstrumentation flags system added by PR dotnet#126091 was not aware of this. The new flags only got set via ETW OnEventCommand, so non-ETW RuntimeAsync configs had s_asyncDebuggerActiveFlags stuck at Disabled, preventing NotifyDebuggerOfRuntimeAsyncState from being called. Fix: In InitializeFlags(), check Task.s_asyncDebuggingEnabled as a fallback when s_asyncDebuggerActiveFlags is still Disabled. This ensures the debugger's request is honored regardless of whether ETW events have been enabled. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

dotnet-policy-service · 2026-04-21T18:01:03Z

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

This PR updates CoreLib’s AsyncInstrumentation initialization so RuntimeAsync debugging instrumentation is enabled when the debugger toggles Task.s_asyncDebuggingEnabled directly (e.g., via ICorDebug) even if no ETW session ever triggers TplEventSource.OnEventCommand.

Changes:

In AsyncInstrumentation.InitializeFlags(), if debugger flags are still Disabled but Task.s_asyncDebuggingEnabled is true, enable DefaultFlags | Flags.AsyncDebugger as a fallback.
Preserve the existing ETW-driven flag update path (the fallback only applies when s_asyncDebuggerActiveFlags is still Disabled).

Copilot · 2026-04-21T18:03:36Z

+ // The debugger may have set Task.s_asyncDebuggingEnabled directly via ICorDebug
+ // before any ETW session is established. In that case, s_asyncDebuggerActiveFlags
+ // will still be Disabled because OnEventCommand was never called. Honor the
+ // debugger's request by enabling default flags when s_asyncDebuggingEnabled is set.
+ if (s_asyncDebuggerActiveFlags == Flags.Disabled && Task.s_asyncDebuggingEnabled)
+ {
+ s_asyncDebuggerActiveFlags = DefaultFlags | Flags.AsyncDebugger;
+ }


This new fallback behavior (enabling AsyncInstrumentation when only Task.s_asyncDebuggingEnabled is set, without an ETW session) doesn’t appear to be covered by existing runtime-async tests. Consider adding a test that sets Task.s_asyncDebuggingEnabled via reflection without creating a TplEventSource listener, then triggers flag initialization (e.g., via a RuntimeAsyncMethodGeneration async method) and asserts AsyncInstrumentation.s_activeFlags becomes enabled (and that the relevant runtime-async collections are initialized as expected).

Copilot · 2026-04-21T18:03:37Z

+ if (s_asyncDebuggerActiveFlags == Flags.Disabled && Task.s_asyncDebuggingEnabled)
+ {
+ s_asyncDebuggerActiveFlags = DefaultFlags | Flags.AsyncDebugger;
+ }


With this change, if Task.s_asyncDebuggingEnabled is later cleared (e.g., debugger detach) in a non-ETW scenario where OnEventCommand never calls UpdateAsyncDebuggerFlags(Disabled), s_asyncDebuggerActiveFlags/s_activeFlags will remain non-Disabled and keep routing RuntimeAsyncTask through the instrumented path (even though AsyncDebugger hooks will be gated by Task.s_asyncDebuggingEnabled). If detach/toggling is expected to work without ETW, consider adding a corresponding “disable” path (e.g., re-check Task.s_asyncDebuggingEnabled in SyncActiveFlags/InstrumentCheckPoint or another explicit update mechanism).

lateralusX · 2026-04-21T19:31:03Z

Let's fix this at debugger side, debugger can set the debugger flag directly in s_asyncDebuggerActiveFlags as done in this fix and it will get picked up when flags initialize synchronize in first async method running through the dispatch continuations loop. Once set o the debugger side we can drop the use of s_asyncDebuggingEnabled inside the asyncv2 instrumentation paths.

lateralusX · 2026-04-23T13:34:47Z

#127238 implements the solution for this.

tommcdon · 2026-04-21T17:58:52Z

When the debugger sets Task.s_asyncDebuggingEnabled directly via ICorDebug (SetManagedTaskEtwEventsEnabled), the AsyncInstrumentation flags system added by PR #126091 was not aware of this. The new flags only got set via ETW OnEventCommand, so non-ETW RuntimeAsync configs had s_asyncDebuggerActiveFlags stuck at Disabled, preventing NotifyDebuggerOfRuntimeAsyncState from being called.

Fix: In InitializeFlags(), check Task.s_asyncDebuggingEnabled as a fallback when s_asyncDebuggerActiveFlags is still Disabled. This ensures the debugger's request is honored regardless of whether ETW events have been enabled.

…rDebug When the debugger sets Task.s_asyncDebuggingEnabled directly via ICorDebug (SetManagedTaskEtwEventsEnabled), the AsyncInstrumentation flags system added by PR dotnet#126091 was not aware of this. The new flags only got set via ETW OnEventCommand, so non-ETW RuntimeAsync configs had s_asyncDebuggerActiveFlags stuck at Disabled, preventing NotifyDebuggerOfRuntimeAsyncState from being called. Fix: In InitializeFlags(), check Task.s_asyncDebuggingEnabled as a fallback when s_asyncDebuggerActiveFlags is still Disabled. This ensures the debugger's request is honored regardless of whether ETW events have been enabled. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

dotnet-policy-service · 2026-04-21T18:01:03Z

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

This PR updates CoreLib’s AsyncInstrumentation initialization so RuntimeAsync debugging instrumentation is enabled when the debugger toggles Task.s_asyncDebuggingEnabled directly (e.g., via ICorDebug) even if no ETW session ever triggers TplEventSource.OnEventCommand.

Changes:

In AsyncInstrumentation.InitializeFlags(), if debugger flags are still Disabled but Task.s_asyncDebuggingEnabled is true, enable DefaultFlags | Flags.AsyncDebugger as a fallback.
Preserve the existing ETW-driven flag update path (the fallback only applies when s_asyncDebuggerActiveFlags is still Disabled).

Copilot · 2026-04-21T18:03:36Z

+ // The debugger may have set Task.s_asyncDebuggingEnabled directly via ICorDebug
+ // before any ETW session is established. In that case, s_asyncDebuggerActiveFlags
+ // will still be Disabled because OnEventCommand was never called. Honor the
+ // debugger's request by enabling default flags when s_asyncDebuggingEnabled is set.
+ if (s_asyncDebuggerActiveFlags == Flags.Disabled && Task.s_asyncDebuggingEnabled)
+ {
+ s_asyncDebuggerActiveFlags = DefaultFlags | Flags.AsyncDebugger;
+ }


This new fallback behavior (enabling AsyncInstrumentation when only Task.s_asyncDebuggingEnabled is set, without an ETW session) doesn’t appear to be covered by existing runtime-async tests. Consider adding a test that sets Task.s_asyncDebuggingEnabled via reflection without creating a TplEventSource listener, then triggers flag initialization (e.g., via a RuntimeAsyncMethodGeneration async method) and asserts AsyncInstrumentation.s_activeFlags becomes enabled (and that the relevant runtime-async collections are initialized as expected).

Copilot · 2026-04-21T18:03:37Z

+ if (s_asyncDebuggerActiveFlags == Flags.Disabled && Task.s_asyncDebuggingEnabled)
+ {
+ s_asyncDebuggerActiveFlags = DefaultFlags | Flags.AsyncDebugger;
+ }


With this change, if Task.s_asyncDebuggingEnabled is later cleared (e.g., debugger detach) in a non-ETW scenario where OnEventCommand never calls UpdateAsyncDebuggerFlags(Disabled), s_asyncDebuggerActiveFlags/s_activeFlags will remain non-Disabled and keep routing RuntimeAsyncTask through the instrumented path (even though AsyncDebugger hooks will be gated by Task.s_asyncDebuggingEnabled). If detach/toggling is expected to work without ETW, consider adding a corresponding “disable” path (e.g., re-check Task.s_asyncDebuggingEnabled in SyncActiveFlags/InstrumentCheckPoint or another explicit update mechanism).

lateralusX · 2026-04-21T19:31:03Z

Let's fix this at debugger side, debugger can set the debugger flag directly in s_asyncDebuggerActiveFlags as done in this fix and it will get picked up when flags initialize synchronize in first async method running through the dispatch continuations loop. Once set o the debugger side we can drop the use of s_asyncDebuggingEnabled inside the asyncv2 instrumentation paths.

lateralusX · 2026-04-23T13:34:47Z

#127238 implements the solution for this.

tommcdon · 2026-04-21T17:58:52Z

When the debugger sets Task.s_asyncDebuggingEnabled directly via ICorDebug (SetManagedTaskEtwEventsEnabled), the AsyncInstrumentation flags system added by PR #126091 was not aware of this. The new flags only got set via ETW OnEventCommand, so non-ETW RuntimeAsync configs had s_asyncDebuggerActiveFlags stuck at Disabled, preventing NotifyDebuggerOfRuntimeAsyncState from being called.

Fix: In InitializeFlags(), check Task.s_asyncDebuggingEnabled as a fallback when s_asyncDebuggerActiveFlags is still Disabled. This ensures the debugger's request is honored regardless of whether ETW events have been enabled.

…rDebug When the debugger sets Task.s_asyncDebuggingEnabled directly via ICorDebug (SetManagedTaskEtwEventsEnabled), the AsyncInstrumentation flags system added by PR dotnet#126091 was not aware of this. The new flags only got set via ETW OnEventCommand, so non-ETW RuntimeAsync configs had s_asyncDebuggerActiveFlags stuck at Disabled, preventing NotifyDebuggerOfRuntimeAsyncState from being called. Fix: In InitializeFlags(), check Task.s_asyncDebuggingEnabled as a fallback when s_asyncDebuggerActiveFlags is still Disabled. This ensures the debugger's request is honored regardless of whether ETW events have been enabled. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

dotnet-policy-service · 2026-04-21T18:01:03Z

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

This PR updates CoreLib’s AsyncInstrumentation initialization so RuntimeAsync debugging instrumentation is enabled when the debugger toggles Task.s_asyncDebuggingEnabled directly (e.g., via ICorDebug) even if no ETW session ever triggers TplEventSource.OnEventCommand.

Changes:

In AsyncInstrumentation.InitializeFlags(), if debugger flags are still Disabled but Task.s_asyncDebuggingEnabled is true, enable DefaultFlags | Flags.AsyncDebugger as a fallback.
Preserve the existing ETW-driven flag update path (the fallback only applies when s_asyncDebuggerActiveFlags is still Disabled).

Copilot · 2026-04-21T18:03:36Z

+ // The debugger may have set Task.s_asyncDebuggingEnabled directly via ICorDebug
+ // before any ETW session is established. In that case, s_asyncDebuggerActiveFlags
+ // will still be Disabled because OnEventCommand was never called. Honor the
+ // debugger's request by enabling default flags when s_asyncDebuggingEnabled is set.
+ if (s_asyncDebuggerActiveFlags == Flags.Disabled && Task.s_asyncDebuggingEnabled)
+ {
+ s_asyncDebuggerActiveFlags = DefaultFlags | Flags.AsyncDebugger;
+ }


This new fallback behavior (enabling AsyncInstrumentation when only Task.s_asyncDebuggingEnabled is set, without an ETW session) doesn’t appear to be covered by existing runtime-async tests. Consider adding a test that sets Task.s_asyncDebuggingEnabled via reflection without creating a TplEventSource listener, then triggers flag initialization (e.g., via a RuntimeAsyncMethodGeneration async method) and asserts AsyncInstrumentation.s_activeFlags becomes enabled (and that the relevant runtime-async collections are initialized as expected).

Copilot · 2026-04-21T18:03:37Z

+ if (s_asyncDebuggerActiveFlags == Flags.Disabled && Task.s_asyncDebuggingEnabled)
+ {
+ s_asyncDebuggerActiveFlags = DefaultFlags | Flags.AsyncDebugger;
+ }


With this change, if Task.s_asyncDebuggingEnabled is later cleared (e.g., debugger detach) in a non-ETW scenario where OnEventCommand never calls UpdateAsyncDebuggerFlags(Disabled), s_asyncDebuggerActiveFlags/s_activeFlags will remain non-Disabled and keep routing RuntimeAsyncTask through the instrumented path (even though AsyncDebugger hooks will be gated by Task.s_asyncDebuggingEnabled). If detach/toggling is expected to work without ETW, consider adding a corresponding “disable” path (e.g., re-check Task.s_asyncDebuggingEnabled in SyncActiveFlags/InstrumentCheckPoint or another explicit update mechanism).

lateralusX · 2026-04-21T19:31:03Z

Let's fix this at debugger side, debugger can set the debugger flag directly in s_asyncDebuggerActiveFlags as done in this fix and it will get picked up when flags initialize synchronize in first async method running through the dispatch continuations loop. Once set o the debugger side we can drop the use of s_asyncDebuggingEnabled inside the asyncv2 instrumentation paths.

lateralusX · 2026-04-23T13:34:47Z

#127238 implements the solution for this.

tommcdon · 2026-04-21T17:58:52Z

When the debugger sets Task.s_asyncDebuggingEnabled directly via ICorDebug (SetManagedTaskEtwEventsEnabled), the AsyncInstrumentation flags system added by PR #126091 was not aware of this. The new flags only got set via ETW OnEventCommand, so non-ETW RuntimeAsync configs had s_asyncDebuggerActiveFlags stuck at Disabled, preventing NotifyDebuggerOfRuntimeAsyncState from being called.

Fix: In InitializeFlags(), check Task.s_asyncDebuggingEnabled as a fallback when s_asyncDebuggerActiveFlags is still Disabled. This ensures the debugger's request is honored regardless of whether ETW events have been enabled.

…rDebug When the debugger sets Task.s_asyncDebuggingEnabled directly via ICorDebug (SetManagedTaskEtwEventsEnabled), the AsyncInstrumentation flags system added by PR dotnet#126091 was not aware of this. The new flags only got set via ETW OnEventCommand, so non-ETW RuntimeAsync configs had s_asyncDebuggerActiveFlags stuck at Disabled, preventing NotifyDebuggerOfRuntimeAsyncState from being called. Fix: In InitializeFlags(), check Task.s_asyncDebuggingEnabled as a fallback when s_asyncDebuggerActiveFlags is still Disabled. This ensures the debugger's request is honored regardless of whether ETW events have been enabled. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

dotnet-policy-service · 2026-04-21T18:01:03Z

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

This PR updates CoreLib’s AsyncInstrumentation initialization so RuntimeAsync debugging instrumentation is enabled when the debugger toggles Task.s_asyncDebuggingEnabled directly (e.g., via ICorDebug) even if no ETW session ever triggers TplEventSource.OnEventCommand.

Changes:

In AsyncInstrumentation.InitializeFlags(), if debugger flags are still Disabled but Task.s_asyncDebuggingEnabled is true, enable DefaultFlags | Flags.AsyncDebugger as a fallback.
Preserve the existing ETW-driven flag update path (the fallback only applies when s_asyncDebuggerActiveFlags is still Disabled).

Copilot · 2026-04-21T18:03:36Z

+ // The debugger may have set Task.s_asyncDebuggingEnabled directly via ICorDebug
+ // before any ETW session is established. In that case, s_asyncDebuggerActiveFlags
+ // will still be Disabled because OnEventCommand was never called. Honor the
+ // debugger's request by enabling default flags when s_asyncDebuggingEnabled is set.
+ if (s_asyncDebuggerActiveFlags == Flags.Disabled && Task.s_asyncDebuggingEnabled)
+ {
+ s_asyncDebuggerActiveFlags = DefaultFlags | Flags.AsyncDebugger;
+ }


This new fallback behavior (enabling AsyncInstrumentation when only Task.s_asyncDebuggingEnabled is set, without an ETW session) doesn’t appear to be covered by existing runtime-async tests. Consider adding a test that sets Task.s_asyncDebuggingEnabled via reflection without creating a TplEventSource listener, then triggers flag initialization (e.g., via a RuntimeAsyncMethodGeneration async method) and asserts AsyncInstrumentation.s_activeFlags becomes enabled (and that the relevant runtime-async collections are initialized as expected).

Copilot · 2026-04-21T18:03:37Z

+ if (s_asyncDebuggerActiveFlags == Flags.Disabled && Task.s_asyncDebuggingEnabled)
+ {
+ s_asyncDebuggerActiveFlags = DefaultFlags | Flags.AsyncDebugger;
+ }


With this change, if Task.s_asyncDebuggingEnabled is later cleared (e.g., debugger detach) in a non-ETW scenario where OnEventCommand never calls UpdateAsyncDebuggerFlags(Disabled), s_asyncDebuggerActiveFlags/s_activeFlags will remain non-Disabled and keep routing RuntimeAsyncTask through the instrumented path (even though AsyncDebugger hooks will be gated by Task.s_asyncDebuggingEnabled). If detach/toggling is expected to work without ETW, consider adding a corresponding “disable” path (e.g., re-check Task.s_asyncDebuggingEnabled in SyncActiveFlags/InstrumentCheckPoint or another explicit update mechanism).

lateralusX · 2026-04-21T19:31:03Z

Let's fix this at debugger side, debugger can set the debugger flag directly in s_asyncDebuggerActiveFlags as done in this fix and it will get picked up when flags initialize synchronize in first async method running through the dispatch continuations loop. Once set o the debugger side we can drop the use of s_asyncDebuggingEnabled inside the asyncv2 instrumentation paths.

lateralusX · 2026-04-23T13:34:47Z

#127238 implements the solution for this.

tommcdon · 2026-04-21T17:58:52Z

When the debugger sets Task.s_asyncDebuggingEnabled directly via ICorDebug (SetManagedTaskEtwEventsEnabled), the AsyncInstrumentation flags system added by PR #126091 was not aware of this. The new flags only got set via ETW OnEventCommand, so non-ETW RuntimeAsync configs had s_asyncDebuggerActiveFlags stuck at Disabled, preventing NotifyDebuggerOfRuntimeAsyncState from being called.

Fix: In InitializeFlags(), check Task.s_asyncDebuggingEnabled as a fallback when s_asyncDebuggerActiveFlags is still Disabled. This ensures the debugger's request is honored regardless of whether ETW events have been enabled.

…rDebug When the debugger sets Task.s_asyncDebuggingEnabled directly via ICorDebug (SetManagedTaskEtwEventsEnabled), the AsyncInstrumentation flags system added by PR dotnet#126091 was not aware of this. The new flags only got set via ETW OnEventCommand, so non-ETW RuntimeAsync configs had s_asyncDebuggerActiveFlags stuck at Disabled, preventing NotifyDebuggerOfRuntimeAsyncState from being called. Fix: In InitializeFlags(), check Task.s_asyncDebuggingEnabled as a fallback when s_asyncDebuggerActiveFlags is still Disabled. This ensures the debugger's request is honored regardless of whether ETW events have been enabled. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

dotnet-policy-service · 2026-04-21T18:01:03Z

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

This PR updates CoreLib’s AsyncInstrumentation initialization so RuntimeAsync debugging instrumentation is enabled when the debugger toggles Task.s_asyncDebuggingEnabled directly (e.g., via ICorDebug) even if no ETW session ever triggers TplEventSource.OnEventCommand.

Changes:

In AsyncInstrumentation.InitializeFlags(), if debugger flags are still Disabled but Task.s_asyncDebuggingEnabled is true, enable DefaultFlags | Flags.AsyncDebugger as a fallback.
Preserve the existing ETW-driven flag update path (the fallback only applies when s_asyncDebuggerActiveFlags is still Disabled).

Copilot · 2026-04-21T18:03:36Z

+ // The debugger may have set Task.s_asyncDebuggingEnabled directly via ICorDebug
+ // before any ETW session is established. In that case, s_asyncDebuggerActiveFlags
+ // will still be Disabled because OnEventCommand was never called. Honor the
+ // debugger's request by enabling default flags when s_asyncDebuggingEnabled is set.
+ if (s_asyncDebuggerActiveFlags == Flags.Disabled && Task.s_asyncDebuggingEnabled)
+ {
+ s_asyncDebuggerActiveFlags = DefaultFlags | Flags.AsyncDebugger;
+ }


This new fallback behavior (enabling AsyncInstrumentation when only Task.s_asyncDebuggingEnabled is set, without an ETW session) doesn’t appear to be covered by existing runtime-async tests. Consider adding a test that sets Task.s_asyncDebuggingEnabled via reflection without creating a TplEventSource listener, then triggers flag initialization (e.g., via a RuntimeAsyncMethodGeneration async method) and asserts AsyncInstrumentation.s_activeFlags becomes enabled (and that the relevant runtime-async collections are initialized as expected).

Copilot · 2026-04-21T18:03:37Z

+ if (s_asyncDebuggerActiveFlags == Flags.Disabled && Task.s_asyncDebuggingEnabled)
+ {
+ s_asyncDebuggerActiveFlags = DefaultFlags | Flags.AsyncDebugger;
+ }


With this change, if Task.s_asyncDebuggingEnabled is later cleared (e.g., debugger detach) in a non-ETW scenario where OnEventCommand never calls UpdateAsyncDebuggerFlags(Disabled), s_asyncDebuggerActiveFlags/s_activeFlags will remain non-Disabled and keep routing RuntimeAsyncTask through the instrumented path (even though AsyncDebugger hooks will be gated by Task.s_asyncDebuggingEnabled). If detach/toggling is expected to work without ETW, consider adding a corresponding “disable” path (e.g., re-check Task.s_asyncDebuggingEnabled in SyncActiveFlags/InstrumentCheckPoint or another explicit update mechanism).

lateralusX · 2026-04-21T19:31:03Z

Let's fix this at debugger side, debugger can set the debugger flag directly in s_asyncDebuggerActiveFlags as done in this fix and it will get picked up when flags initialize synchronize in first async method running through the dispatch continuations loop. Once set o the debugger side we can drop the use of s_asyncDebuggingEnabled inside the asyncv2 instrumentation paths.

lateralusX · 2026-04-23T13:34:47Z

#127238 implements the solution for this.

tommcdon · 2026-04-21T17:58:52Z

When the debugger sets Task.s_asyncDebuggingEnabled directly via ICorDebug (SetManagedTaskEtwEventsEnabled), the AsyncInstrumentation flags system added by PR #126091 was not aware of this. The new flags only got set via ETW OnEventCommand, so non-ETW RuntimeAsync configs had s_asyncDebuggerActiveFlags stuck at Disabled, preventing NotifyDebuggerOfRuntimeAsyncState from being called.

Fix: In InitializeFlags(), check Task.s_asyncDebuggingEnabled as a fallback when s_asyncDebuggerActiveFlags is still Disabled. This ensures the debugger's request is honored regardless of whether ETW events have been enabled.

…rDebug When the debugger sets Task.s_asyncDebuggingEnabled directly via ICorDebug (SetManagedTaskEtwEventsEnabled), the AsyncInstrumentation flags system added by PR dotnet#126091 was not aware of this. The new flags only got set via ETW OnEventCommand, so non-ETW RuntimeAsync configs had s_asyncDebuggerActiveFlags stuck at Disabled, preventing NotifyDebuggerOfRuntimeAsyncState from being called. Fix: In InitializeFlags(), check Task.s_asyncDebuggingEnabled as a fallback when s_asyncDebuggerActiveFlags is still Disabled. This ensures the debugger's request is honored regardless of whether ETW events have been enabled. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

dotnet-policy-service · 2026-04-21T18:01:03Z

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

This PR updates CoreLib’s AsyncInstrumentation initialization so RuntimeAsync debugging instrumentation is enabled when the debugger toggles Task.s_asyncDebuggingEnabled directly (e.g., via ICorDebug) even if no ETW session ever triggers TplEventSource.OnEventCommand.

Changes:

In AsyncInstrumentation.InitializeFlags(), if debugger flags are still Disabled but Task.s_asyncDebuggingEnabled is true, enable DefaultFlags | Flags.AsyncDebugger as a fallback.
Preserve the existing ETW-driven flag update path (the fallback only applies when s_asyncDebuggerActiveFlags is still Disabled).

Copilot · 2026-04-21T18:03:36Z

+ // The debugger may have set Task.s_asyncDebuggingEnabled directly via ICorDebug
+ // before any ETW session is established. In that case, s_asyncDebuggerActiveFlags
+ // will still be Disabled because OnEventCommand was never called. Honor the
+ // debugger's request by enabling default flags when s_asyncDebuggingEnabled is set.
+ if (s_asyncDebuggerActiveFlags == Flags.Disabled && Task.s_asyncDebuggingEnabled)
+ {
+ s_asyncDebuggerActiveFlags = DefaultFlags | Flags.AsyncDebugger;
+ }


This new fallback behavior (enabling AsyncInstrumentation when only Task.s_asyncDebuggingEnabled is set, without an ETW session) doesn’t appear to be covered by existing runtime-async tests. Consider adding a test that sets Task.s_asyncDebuggingEnabled via reflection without creating a TplEventSource listener, then triggers flag initialization (e.g., via a RuntimeAsyncMethodGeneration async method) and asserts AsyncInstrumentation.s_activeFlags becomes enabled (and that the relevant runtime-async collections are initialized as expected).

Copilot · 2026-04-21T18:03:37Z

+ if (s_asyncDebuggerActiveFlags == Flags.Disabled && Task.s_asyncDebuggingEnabled)
+ {
+ s_asyncDebuggerActiveFlags = DefaultFlags | Flags.AsyncDebugger;
+ }


With this change, if Task.s_asyncDebuggingEnabled is later cleared (e.g., debugger detach) in a non-ETW scenario where OnEventCommand never calls UpdateAsyncDebuggerFlags(Disabled), s_asyncDebuggerActiveFlags/s_activeFlags will remain non-Disabled and keep routing RuntimeAsyncTask through the instrumented path (even though AsyncDebugger hooks will be gated by Task.s_asyncDebuggingEnabled). If detach/toggling is expected to work without ETW, consider adding a corresponding “disable” path (e.g., re-check Task.s_asyncDebuggingEnabled in SyncActiveFlags/InstrumentCheckPoint or another explicit update mechanism).

lateralusX · 2026-04-21T19:31:03Z

Let's fix this at debugger side, debugger can set the debugger flag directly in s_asyncDebuggerActiveFlags as done in this fix and it will get picked up when flags initialize synchronize in first async method running through the dispatch continuations loop. Once set o the debugger side we can drop the use of s_asyncDebuggingEnabled inside the asyncv2 instrumentation paths.

lateralusX · 2026-04-23T13:34:47Z

#127238 implements the solution for this.

tommcdon · 2026-04-21T17:58:52Z

When the debugger sets Task.s_asyncDebuggingEnabled directly via ICorDebug (SetManagedTaskEtwEventsEnabled), the AsyncInstrumentation flags system added by PR #126091 was not aware of this. The new flags only got set via ETW OnEventCommand, so non-ETW RuntimeAsync configs had s_asyncDebuggerActiveFlags stuck at Disabled, preventing NotifyDebuggerOfRuntimeAsyncState from being called.

Fix: In InitializeFlags(), check Task.s_asyncDebuggingEnabled as a fallback when s_asyncDebuggerActiveFlags is still Disabled. This ensures the debugger's request is honored regardless of whether ETW events have been enabled.

…rDebug When the debugger sets Task.s_asyncDebuggingEnabled directly via ICorDebug (SetManagedTaskEtwEventsEnabled), the AsyncInstrumentation flags system added by PR dotnet#126091 was not aware of this. The new flags only got set via ETW OnEventCommand, so non-ETW RuntimeAsync configs had s_asyncDebuggerActiveFlags stuck at Disabled, preventing NotifyDebuggerOfRuntimeAsyncState from being called. Fix: In InitializeFlags(), check Task.s_asyncDebuggingEnabled as a fallback when s_asyncDebuggerActiveFlags is still Disabled. This ensures the debugger's request is honored regardless of whether ETW events have been enabled. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

dotnet-policy-service · 2026-04-21T18:01:03Z

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

This PR updates CoreLib’s AsyncInstrumentation initialization so RuntimeAsync debugging instrumentation is enabled when the debugger toggles Task.s_asyncDebuggingEnabled directly (e.g., via ICorDebug) even if no ETW session ever triggers TplEventSource.OnEventCommand.

Changes:

In AsyncInstrumentation.InitializeFlags(), if debugger flags are still Disabled but Task.s_asyncDebuggingEnabled is true, enable DefaultFlags | Flags.AsyncDebugger as a fallback.
Preserve the existing ETW-driven flag update path (the fallback only applies when s_asyncDebuggerActiveFlags is still Disabled).

Copilot · 2026-04-21T18:03:36Z

+ // The debugger may have set Task.s_asyncDebuggingEnabled directly via ICorDebug
+ // before any ETW session is established. In that case, s_asyncDebuggerActiveFlags
+ // will still be Disabled because OnEventCommand was never called. Honor the
+ // debugger's request by enabling default flags when s_asyncDebuggingEnabled is set.
+ if (s_asyncDebuggerActiveFlags == Flags.Disabled && Task.s_asyncDebuggingEnabled)
+ {
+ s_asyncDebuggerActiveFlags = DefaultFlags | Flags.AsyncDebugger;
+ }


This new fallback behavior (enabling AsyncInstrumentation when only Task.s_asyncDebuggingEnabled is set, without an ETW session) doesn’t appear to be covered by existing runtime-async tests. Consider adding a test that sets Task.s_asyncDebuggingEnabled via reflection without creating a TplEventSource listener, then triggers flag initialization (e.g., via a RuntimeAsyncMethodGeneration async method) and asserts AsyncInstrumentation.s_activeFlags becomes enabled (and that the relevant runtime-async collections are initialized as expected).

Copilot · 2026-04-21T18:03:37Z

+ if (s_asyncDebuggerActiveFlags == Flags.Disabled && Task.s_asyncDebuggingEnabled)
+ {
+ s_asyncDebuggerActiveFlags = DefaultFlags | Flags.AsyncDebugger;
+ }


With this change, if Task.s_asyncDebuggingEnabled is later cleared (e.g., debugger detach) in a non-ETW scenario where OnEventCommand never calls UpdateAsyncDebuggerFlags(Disabled), s_asyncDebuggerActiveFlags/s_activeFlags will remain non-Disabled and keep routing RuntimeAsyncTask through the instrumented path (even though AsyncDebugger hooks will be gated by Task.s_asyncDebuggingEnabled). If detach/toggling is expected to work without ETW, consider adding a corresponding “disable” path (e.g., re-check Task.s_asyncDebuggingEnabled in SyncActiveFlags/InstrumentCheckPoint or another explicit update mechanism).

lateralusX · 2026-04-21T19:31:03Z

Let's fix this at debugger side, debugger can set the debugger flag directly in s_asyncDebuggerActiveFlags as done in this fix and it will get picked up when flags initialize synchronize in first async method running through the dispatch continuations loop. Once set o the debugger side we can drop the use of s_asyncDebuggingEnabled inside the asyncv2 instrumentation paths.

lateralusX · 2026-04-23T13:34:47Z

#127238 implements the solution for this.

tommcdon added this to the 11.0.0 milestone Apr 21, 2026

tommcdon requested review from lateralusX and noahfalk April 21, 2026 17:58

tommcdon self-assigned this Apr 21, 2026

CopilotAI review requested due to automatic review settings April 21, 2026 17:58

tommcdon added the area-Diagnostics-coreclr label Apr 21, 2026

Copilotstarted reviewing on behalf of tommcdon April 21, 2026 17:59 View session

CopilotAI reviewed Apr 21, 2026
View reviewed changes

tommcdon closed this Apr 21, 2026

github-actionsBot locked and limited conversation to collaborators May 22, 2026

tommcdon added this to the 11.0.0 milestone Apr 21, 2026

tommcdon requested review from lateralusX and noahfalk April 21, 2026 17:58

tommcdon self-assigned this Apr 21, 2026

CopilotAI review requested due to automatic review settings April 21, 2026 17:58

tommcdon added the area-Diagnostics-coreclr label Apr 21, 2026

Copilotstarted reviewing on behalf of tommcdon April 21, 2026 17:59 View session

CopilotAI reviewed Apr 21, 2026
View reviewed changes

tommcdon closed this Apr 21, 2026

github-actionsBot locked and limited conversation to collaborators May 22, 2026

tommcdon added this to the 11.0.0 milestone Apr 21, 2026

tommcdon requested review from lateralusX and noahfalk April 21, 2026 17:58

tommcdon self-assigned this Apr 21, 2026

CopilotAI review requested due to automatic review settings April 21, 2026 17:58

tommcdon added the area-Diagnostics-coreclr label Apr 21, 2026

Copilotstarted reviewing on behalf of tommcdon April 21, 2026 17:59 View session

CopilotAI reviewed Apr 21, 2026
View reviewed changes

tommcdon closed this Apr 21, 2026

github-actionsBot locked and limited conversation to collaborators May 22, 2026

tommcdon added this to the 11.0.0 milestone Apr 21, 2026

tommcdon requested review from lateralusX and noahfalk April 21, 2026 17:58

tommcdon self-assigned this Apr 21, 2026

CopilotAI review requested due to automatic review settings April 21, 2026 17:58

tommcdon added the area-Diagnostics-coreclr label Apr 21, 2026

Copilotstarted reviewing on behalf of tommcdon April 21, 2026 17:59 View session

CopilotAI reviewed Apr 21, 2026
View reviewed changes

tommcdon closed this Apr 21, 2026

github-actionsBot locked and limited conversation to collaborators May 22, 2026

tommcdon added this to the 11.0.0 milestone Apr 21, 2026

tommcdon requested review from lateralusX and noahfalk April 21, 2026 17:58

tommcdon self-assigned this Apr 21, 2026

CopilotAI review requested due to automatic review settings April 21, 2026 17:58

tommcdon added the area-Diagnostics-coreclr label Apr 21, 2026

Copilotstarted reviewing on behalf of tommcdon April 21, 2026 17:59 View session

CopilotAI reviewed Apr 21, 2026
View reviewed changes

tommcdon closed this Apr 21, 2026

github-actionsBot locked and limited conversation to collaborators May 22, 2026

tommcdon added this to the 11.0.0 milestone Apr 21, 2026

tommcdon requested review from lateralusX and noahfalk April 21, 2026 17:58

tommcdon self-assigned this Apr 21, 2026

CopilotAI review requested due to automatic review settings April 21, 2026 17:58

tommcdon added the area-Diagnostics-coreclr label Apr 21, 2026

Copilotstarted reviewing on behalf of tommcdon April 21, 2026 17:59 View session

CopilotAI reviewed Apr 21, 2026
View reviewed changes

tommcdon closed this Apr 21, 2026

github-actionsBot locked and limited conversation to collaborators May 22, 2026

tommcdon added this to the 11.0.0 milestone Apr 21, 2026

tommcdon requested review from lateralusX and noahfalk April 21, 2026 17:58

tommcdon self-assigned this Apr 21, 2026

CopilotAI review requested due to automatic review settings April 21, 2026 17:58

tommcdon added the area-Diagnostics-coreclr label Apr 21, 2026

Copilotstarted reviewing on behalf of tommcdon April 21, 2026 17:59 View session

CopilotAI reviewed Apr 21, 2026
View reviewed changes

tommcdon closed this Apr 21, 2026

github-actionsBot locked and limited conversation to collaborators May 22, 2026

tommcdon added this to the 11.0.0 milestone Apr 21, 2026

tommcdon requested review from lateralusX and noahfalk April 21, 2026 17:58

tommcdon self-assigned this Apr 21, 2026

CopilotAI review requested due to automatic review settings April 21, 2026 17:58

tommcdon added the area-Diagnostics-coreclr label Apr 21, 2026

Copilotstarted reviewing on behalf of tommcdon April 21, 2026 17:59 View session

CopilotAI reviewed Apr 21, 2026
View reviewed changes

tommcdon closed this Apr 21, 2026

github-actionsBot locked and limited conversation to collaborators May 22, 2026

Uh oh!

Conversation

tommcdon commented Apr 21, 2026

Uh oh!

dotnet-policy-serviceBot commented Apr 21, 2026

Uh oh!

CopilotAI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

CopilotAIApr 21, 2026

Choose a reason for hiding this comment

Uh oh!

CopilotAIApr 21, 2026

Choose a reason for hiding this comment

Uh oh!

lateralusX commented Apr 21, 2026• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

lateralusX commented Apr 23, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Uh oh!

Conversation

tommcdon commented Apr 21, 2026

Uh oh!

dotnet-policy-serviceBot commented Apr 21, 2026

Uh oh!

CopilotAI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

CopilotAIApr 21, 2026

Choose a reason for hiding this comment

Uh oh!

CopilotAIApr 21, 2026

Choose a reason for hiding this comment

Uh oh!

lateralusX commented Apr 21, 2026• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

lateralusX commented Apr 23, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Uh oh!

Conversation

tommcdon commented Apr 21, 2026

Uh oh!

dotnet-policy-serviceBot commented Apr 21, 2026

Uh oh!

CopilotAI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

CopilotAIApr 21, 2026

Choose a reason for hiding this comment

Uh oh!

CopilotAIApr 21, 2026

Choose a reason for hiding this comment

Uh oh!

lateralusX commented Apr 21, 2026• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

lateralusX commented Apr 23, 2026

Uh oh!

Reviewers

lateralusX commented Apr 21, 2026•
edited
Loading

lateralusX commented Apr 21, 2026•
edited
Loading

lateralusX commented Apr 21, 2026•
edited
Loading

lateralusX commented Apr 21, 2026•
edited
Loading