Serialize network detector lifecycle changes

Protect all Start and Stop access to the worker thread with a dedicated lifecycle mutex so shutdown cannot miss an unpublished thread. Add a concurrent startup/shutdown regression test.

Show total possible leaks and total reachable allocations in the job summary so every baseline-checked metric is directly interpretable.

Files changed:
- .github/scripts/run-drmemory.ps1
- lib/pal/desktop/NetworkDetector.cpp
- lib/pal/desktop/NetworkDetector.hpp
- tests/unittests/NetworkDetectorTests.cpp

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: bmehta001

.github/scripts/run-drmemory.ps1

@@ -143,9 +143,9 @@ if ($BaselinePath) {
 }
 
 $markdown = @"
-| Scenario | Unique leaks | Total leaks | Leak bytes | Unique possible | Possible bytes | Unique reachable | Reachable bytes | Baseline |
-|---|---:|---:|---:|---:|---:|---:|---:|---|
-| $Scenario | $($leaks.Unique) | $($leaks.Total) | $($leaks.Bytes) | $($possibleLeaks.Unique) | $($possibleLeaks.Bytes) | $($reachable.Unique) | $($reachable.Bytes) | $baselineStatus |
+| Scenario | Unique leaks | Total leaks | Leak bytes | Unique possible | Total possible | Possible bytes | Unique reachable | Total reachable | Reachable bytes | Baseline |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---|
+| $Scenario | $($leaks.Unique) | $($leaks.Total) | $($leaks.Bytes) | $($possibleLeaks.Unique) | $($possibleLeaks.Total) | $($possibleLeaks.Bytes) | $($reachable.Unique) | $($reachable.Total) | $($reachable.Bytes) | $baselineStatus |
 "@
 Write-Host $markdown
 if ($env:GITHUB_STEP_SUMMARY) {

lib/pal/desktop/NetworkDetector.cpp

@@ -333,6 +333,7 @@ namespace MAT_NS_BEGIN
         /// <returns>true - if start is successful, false - otherwise</returns>
         bool NetworkDetector::Start()
         {
+            std::lock_guard<std::mutex> lifecycleLock(m_lifecycleLock);
             {
                 std::unique_lock<std::mutex> lock(m_lock);
                 if (startupState == StartupState::Starting)
@@ -425,6 +426,7 @@ namespace MAT_NS_BEGIN
         /// </summary>
         void NetworkDetector::Stop()
         {
+            std::lock_guard<std::mutex> lifecycleLock(m_lifecycleLock);
             if (netDetectThread.joinable())
             {
                 {

lib/pal/desktop/NetworkDetector.hpp

@@ -59,19 +59,19 @@ namespace MAT_NS_BEGIN
                     /// <summary>
                     /// Current network info stats
                     /// </summary>
-                    ComPtr<INetworkInformationStatics>  networkInfoStats;
+                    ComPtr<INetworkInformationStatics> networkInfoStats;
                     ComPtr<INetworkStatusChangedEventHandler> networkStatusChangedHandler;
-                    EventRegistrationToken              networkStatusChangedToken{};
-                    std::shared_ptr<CallbackState>       networkStatusCallbackState;
-
+                    EventRegistrationToken networkStatusChangedToken{};
+                    std::shared_ptr<CallbackState> networkStatusCallbackState;
 
                     /// <summary>
                     /// Get instance of network info stats
                     /// </summary>
                     /// <returns></returns>
                     bool GetNetworkInfoStats();
 
-                    std::mutex                          m_lock;
+                    std::mutex m_lifecycleLock;
+                    std::mutex m_lock;
                     std::condition_variable cv;
                     std::atomic<bool> isRunning{false};
                     std::thread netDetectThread;
@@ -84,7 +84,7 @@ namespace MAT_NS_BEGIN
                     /// </summary>
                     void run();
 
-                    DWORD                               m_listener_tid = 0;
+                    DWORD m_listener_tid = 0;
 
                     /// <summary>
                     /// Register and listen to network state notifications

tests/unittests/NetworkDetectorTests.cpp

@@ -64,4 +64,26 @@ TEST(NetworkDetectorTests, QueuedNetworkCallbackRaceDoesNotOutliveStop)
     keepQueuing.store(false, std::memory_order_release);
     callbackThread.join();
 }
+
+TEST(NetworkDetectorTests, ConcurrentStopWaitsForStartupPublication)
+{
+    for (int iteration = 0; iteration < 20; ++iteration)
+    {
+        MATW::NetworkDetector detector;
+        std::atomic<bool> startReturned{false};
+        std::thread startThread([&]()
+                                {
+            detector.Start();
+            startReturned.store(true, std::memory_order_release); });
+
+        while (!detector.isUp() && !startReturned.load(std::memory_order_acquire))
+        {
+            std::this_thread::yield();
+        }
+
+        detector.Stop();
+        startThread.join();
+        EXPECT_FALSE(detector.isUp());
+    }
+}
 #endif