[release/9.0-staging] Fix race condition in cleanup of collectible th…

…read static variables (#111275) * Fix issue 110837 There was a race condition where we could have collected all of the managed state of a LoaderAllocator, but not yet started cleaning up the actual LoaderAllocator object in native code. If a thread which had a TLS variable defined in a code associated with a collectible loader allocator was terminated at that point, then the runtime would crash. The fix is to detect if the LoaderAllocator managed state is still alive, and if so, do not attempt to clean it up. * Disable test on NativeAOT * Update src/tests/Loader/CollectibleAssemblies/Statics/CollectibleTLSStaticCollection.cs Co-authored-by: Copilot <[email protected]> * Update src/tests/Loader/CollectibleAssemblies/Statics/CollectibleTLSStaticCollection.cs Co-authored-by: Copilot <[email protected]> * Fix missing adjustment missed by copilot --------- Co-authored-by: David Wrighton <[email protected]> Co-authored-by: Copilot <[email protected]>
dotnet · carlossanlop · Feb 11, 2025 · Jan 15, 2025 · Jan 15, 2025 · Jan 15, 2025
commit ea5e814ba00d050073c1026e0c6800cb7208e310
diff --git a/src/coreclr/vm/threadstatics.cpp b/src/coreclr/vm/threadstatics.cpp
@@ -377,7 +377,7 @@ void FreeLoaderAllocatorHandlesForTLSData(Thread *pThread)
 #endif
         for (const auto& entry : g_pThreadStaticCollectibleTypeIndices->CollectibleEntries())
         {
-            _ASSERTE((entry.TlsIndex.GetIndexOffset() <= pThread->cLoaderHandles) || allRemainingIndicesAreNotValid);
+            _ASSERTE((entry.TlsIndex.GetIndexOffset() >= pThread->cLoaderHandles) || !allRemainingIndicesAreNotValid);
             if (entry.TlsIndex.GetIndexOffset() >= pThread->cLoaderHandles)
             {
 #ifndef _DEBUG
@@ -390,7 +390,9 @@ void FreeLoaderAllocatorHandlesForTLSData(Thread *pThread)
             {
                 if (pThread->pLoaderHandles[entry.TlsIndex.GetIndexOffset()] != (LOADERHANDLE)NULL)
                 {
-                    entry.pMT->GetLoaderAllocator()->FreeHandle(pThread->pLoaderHandles[entry.TlsIndex.GetIndexOffset()]);
+                    LoaderAllocator *pLoaderAllocator = entry.pMT->GetLoaderAllocator();
+                    if (pLoaderAllocator->IsExposedObjectLive())
+                        pLoaderAllocator->FreeHandle(pThread->pLoaderHandles[entry.TlsIndex.GetIndexOffset()]);
                     pThread->pLoaderHandles[entry.TlsIndex.GetIndexOffset()] = (LOADERHANDLE)NULL;
                 }
             }

diff --git a/src/tests/Loader/CollectibleAssemblies/Statics/CollectibleTLSStaticCollection.cs b/src/tests/Loader/CollectibleAssemblies/Statics/CollectibleTLSStaticCollection.cs
@@ -0,0 +1,103 @@
+// 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.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Threading;
+using Xunit;
+
+namespace CollectibleThreadStaticShutdownRace
+{
+    public class CollectibleThreadStaticShutdownRace
+    {
+        Action? UseTLSStaticFromLoaderAllocator = null;
+        GCHandle IsLoaderAllocatorLive;
+        static ulong s_collectibleIndex;
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        void CallUseTLSStaticFromLoaderAllocator()
+        {
+            UseTLSStaticFromLoaderAllocator!();
+            UseTLSStaticFromLoaderAllocator = null;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        bool CheckLALive()
+        {
+            return IsLoaderAllocatorLive.Target != null;
+        }
+
+
+        void ThreadThatWaitsForLoaderAllocatorToDisappear()
+        {
+            CallUseTLSStaticFromLoaderAllocator();
+            while (CheckLALive())
+            {
+                GC.Collect(2);
+            }
+        }
+
+        void CreateLoaderAllocatorWithTLS()
+        {
+            ulong collectibleIndex = s_collectibleIndex++;
+
+            var ab =
+                AssemblyBuilder.DefineDynamicAssembly(
+                    new AssemblyName($"CollectibleDerivedAssembly{collectibleIndex}"),
+                    AssemblyBuilderAccess.RunAndCollect);
+            var mob = ab.DefineDynamicModule($"CollectibleDerivedModule{collectibleIndex}");
+            var tb =
+                mob.DefineType(
+                    $"CollectibleDerived{collectibleIndex}",
+                    TypeAttributes.Class | TypeAttributes.Public,
+                    typeof(object));
+
+            {
+                var fb =
+                    tb.DefineField(
+                        "Field", typeof(int), FieldAttributes.Static);
+                fb.SetCustomAttribute(typeof(ThreadStaticAttribute).GetConstructors()[0], new byte[0]);
+
+                var mb =
+                    tb.DefineMethod(
+                        "Method",
+                        MethodAttributes.Public | MethodAttributes.Static);
+                var ilg = mb.GetILGenerator();
+                ilg.Emit(OpCodes.Ldc_I4_1);
+                ilg.Emit(OpCodes.Stsfld, fb);
+                ilg.Emit(OpCodes.Ret);
+            }
+
+            Type createdType = tb.CreateType();
+            UseTLSStaticFromLoaderAllocator = (Action)createdType.GetMethods()[0].CreateDelegate(typeof(Action));
+            IsLoaderAllocatorLive = GCHandle.Alloc(createdType, GCHandleType.WeakTrackResurrection);
+        }
+
+        void ForceCollectibleTLSStaticToGoThroughThreadTermination()
+        {
+            int iteration = 0;
+            for (int i = 0; i < 10; i++)
+            {
+                Console.WriteLine($"Iteration {iteration++}");
+                var createLAThread = new Thread(CreateLoaderAllocatorWithTLS);
+                createLAThread.Start();
+                createLAThread.Join();
+
+                var crashThread = new Thread(ThreadThatWaitsForLoaderAllocatorToDisappear);
+                crashThread.Start();
+                crashThread.Join();
+            }
+
+        }
+
+        [Fact]
+        public static void TestEntryPoint()
+        {
+            new CollectibleThreadStaticShutdownRace().ForceCollectibleTLSStaticToGoThroughThreadTermination();
+        }
+    }
+}
+
diff --git a/src/tests/Loader/CollectibleAssemblies/Statics/CollectibleTLSStaticCollection.csproj b/src/tests/Loader/CollectibleAssemblies/Statics/CollectibleTLSStaticCollection.csproj
@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <!-- Needed for mechanical merging of all remaining tests, this particular project may not actually need process isolation -->
+    <RequiresProcessIsolation>true</RequiresProcessIsolation>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="CollectibleTLSStaticCollection.cs" />
+  </ItemGroup>
+</Project>
diff --git a/src/tests/issues.targets b/src/tests/issues.targets
@@ -1010,6 +1010,9 @@
         <ExcludeList Include="$(XunitTestBinBase)/Loader/CollectibleAssemblies/ByRefLocals/ByRefLocals/*">
             <Issue>https://github.com/dotnet/runtimelab/issues/155: Collectible assemblies</Issue>
         </ExcludeList>
+        <ExcludeList Include="$(XunitTestBinBase)/Loader/CollectibleAssemblies/Statics/CollectibleTLSStaticCollection/*">
+            <Issue>https://github.com/dotnet/runtimelab/issues/155: Collectible assemblies</Issue>
+        </ExcludeList>
         <ExcludeList Include="$(XunitTestBinBase)/Loader/CollectibleAssemblies/Statics/CollectibleStatics/*">
             <Issue>https://github.com/dotnet/runtimelab/issues/155: Collectible assemblies</Issue>
         </ExcludeList>