Keep Unix named mutex storage mapped until a native owner thread exits - #137223

Stacked on #136737. This targets that PR's branch (dev/jkoritzinsky/redesigned-potato, head 472d76e0f30) and fixes a failure the PR does not cover.

Problem

When a native (non-.NET) thread owns a pthread-backed named mutex and exits, the runtime detaches the thread while its OS thread is still alive, and the managed ownership cleanup is deferred to the finalizer thread. If that cleanup drops the last reference to the shared memory, SharedMemoryProcessDataHeader.Close calls pthread_mutex_destroy and munmap while the dying OS thread still has the mutex on its kernel robust futex list. The kernel's exit-time exit_robust_list walk then faults reading the unmapped node and silently stops. Every mutex the thread locked earlier is never marked owner-dead and stays locked forever; other waiters time out instead of getting AbandonedMutexException. There is no crash. With a single owned mutex there is no visible effect.

The PR's AbandonLockCore change skips the foreign unlock, but the reference is still dropped and the mapping still unmapped, so this failure remains.

Fix

• Record Thread.CurrentOSThreadId when ownership is recorded.
• In the pthread AbandonLockCore override, when cleanup runs on a thread other than the owner, determine the owner OS thread's state (Running, Exited or Unknown):
  • Exited: nothing changes; the normal close, destroy and unmap proceed.
  • Running: take an extra mapping reference and register a Gen2GcCallback that keeps returning true until the thread has exited, then releases the reference under the creation/deletion lock, which runs the normal close and unlink.
  • Unknown: keep the extra reference until process exit, with no retries.
• The state comes from a new SystemNative_TgKill(pid, tid, 0) helper (syscall(SYS_tgkill) on Linux, ENOSYS elsewhere, including a wasi stub). ESRCH means exited (the kernel unhashes a thread only after its robust list walk); success or any other error such as EPERM means running.
• If tgkill fails with ENOSYS (unsupported platform or a filtered syscall), fall back to /proc/self/task/<tid>: present means running, absent means exited. If /proc/self/task is not available either, the state is Unknown.
• Owner-thread abandonment (managed Thread.Start threads) is unchanged.

Cost: the retry runs after gen 2 GCs, so a quiet process may hold the mapping until one happens; one mapping per event.

Validation

Linux x64, glibc 2.43, kernel 6.18 (WSL2). Release build (./build.sh clr+libs -rc release -lc release) of this branch, i.e. on #136737's base.

• Standalone native harness mirroring pal_crossprocessmutex.c: with a non-owner unlock, destroy and munmap of the last-locked mutex, the earlier mutex stays locked after the owner thread exits (EBUSY/ETIMEDOUT instead of EOWNERDEAD); the control without the unmap recovers (EOWNERDEAD).
• Managed end-to-end repro (native thread acquires two named mutexes, public handles disposed, OS thread held alive after runtime detach with a pthread-key destructor, finalizers driven with GC.Collect(), then the other mutex waited on):
  • Baseline and Fix Unix named mutex ownership recovery races #136737 head (checked on an earlier build of the same file contents): the other mutex is stranded (WaitOne(3000) returns false) in 10/10 runs.
  • This branch with tgkill: 10/10 runs recover it as abandoned. The mapping is present while the owner OS thread is alive and released after it exits. The control with a live alias keeps the mapping in 10/10 runs.
  • This branch with tgkill forced to fail with ENOSYS (an LD_PRELOAD shim, confirmed to intercept the calls): the procfs fallback recovers it in 5/5 runs, with the mapping released after the owner exits.
• dotnet build /t:test src/libraries/System.Threading/tests/System.Threading.Tests.csproj -c Release: Total 770, Failed 0, Skipped 17, including Fix Unix named mutex ownership recovery races #136737's NamedMutex_ReacquireBeforeAbandonedOwnerCleanup (3 rows) and NamedMutex_DeferredAbandonment_DoesNotModifyRecoveredMutex (4 rows).
• dotnet build /t:test src/libraries/System.Threading.Thread/tests/System.Threading.Thread.Tests.csproj -c Release: Total 60, Failed 0, Skipped 9 (run before the procfs fallback commit, which only touches NamedMutex.Unix.cs).

Limitations

• No unit test is included. The failing window needs the OS thread held alive after the runtime detaches it, which needs a native shim and cannot be arranged from managed test code; the repro above is the end-to-end check.
• Only Linux x64 was run. The wasi/browser System.Native builds and non-Linux backends were not built or run, and the Unknown state (no tgkill and no /proc) was not exercised.
• The branch history has several commits because the push was done in pieces; the final tree is the single intended change.