Race condition in gameLoopInitialized causes server hang when starting multiple instances concurrently

[uzapolsky]

Description

When starting multiple CS2 server instances simultaneously from the same installation directory, some servers hang indefinitely during map loading. This is caused by a race condition in the global variable gameLoopInitialized.

Environment

• OS: Ubuntu Linux
• CS2 Server: Dedicated server, 5 instances
• CounterStrikeSharp Version: 1.0.355
• Metamod Version: Latest
• Hardware: 96 CPU cores, 251GB RAM, RAID1 storage

Steps to Reproduce

1. Install CounterStrikeSharp in a single CS2 server directory
2. Start 5+ server instances simultaneously using the same game files:

   for port in 27015 27016 27017 27018 27019; do
     ./cs2 -dedicated -hostport $port +map de_dust2 &
   done

3. Observe that some servers hang during initialization

Expected Behavior

All servers should initialize successfully and load the map, regardless of concurrent startup.

Actual Behavior

• 1-2 servers hang indefinitely (tested with 5 concurrent starts)
• Hung servers show CPU usage (~28%) but make no progress
• Last log entry before hang: CNavGenParams - Nav mesh requests project default generatTotal connected players: 2 (truncated mid-line)
• Process spins in ThreadNanoSleep() loop waiting for an event that never arrives

Root Cause Analysis

Problem Location

File: src/core/globals.cpp:94

bool gameLoopInitialized = false;  // Global variable shared across all processes

File: src/mm_plugin.cpp:292

void CounterStrikeSharpMMPlugin::Hook_RegisterLoopMode(const char* pszLoopModeName, ...)
{
    if (strcmp(pszLoopModeName, "game") == 0)
    {
        if (!globals::gameLoopInitialized) globals::gameLoopInitialized = true;
        CALL_GLOBAL_LISTENER(OnGameLoopInitialized());
    }
}

File: src/core/managers/event_manager.cpp:82

bool EventManager::HookEvent(const char* szName, CallbackT fnCallback, bool bPost)
{
    if (!globals::gameLoopInitialized)
    {
        const PendingEventHook pendingHook{ szName, fnCallback, bPost };
        m_PendingHooks.push(pendingHook);
        return true;
    }
    // ...
}

Race Condition Sequence

1. Multiple server processes share the same .so library memory
2. gameLoopInitialized is a single global variable shared by all processes
3. Race condition occurs:

   Process A: checks gameLoopInitialized == false
   Process B: checks gameLoopInitialized == false
   Process A: sets gameLoopInitialized = true, calls OnGameLoopInitialized()
   Process B: sets gameLoopInitialized = true, but listener ALREADY fired
   Process B: EventManager waits for OnGameLoopInitialized() that never comes
   Process B: m_PendingHooks never processed → server hangs forever
   

Technical Evidence

GDB Stack Trace of Hung Server

Thread 1 (main):
#0  __GI___clock_nanosleep
#1  __GI___nanosleep
#2  ThreadNanoSleep() from libtier0.so
#3  libresourcesystem.so  (spin-wait loop)

System Call Analysis

Hung server makes 30,130 futex calls and 320 clock_nanosleep calls in 5 seconds (6,000+ futex/sec), indicating a busy spin-wait loop.

Perf Profile

10.28% CPU time spent in counterstrikesharp::__SourceHook_FHCls_IServerGameDLLGameFrame0::Func, confirming the hook is active but waiting.

Proposed Solutions

Option 1: Process-Local Variable (Recommended)

Make gameLoopInitialized process-local instead of global. Use thread-local storage or instance variable:

// In mm_plugin.h
class CounterStrikeSharpMMPlugin {
private:
    bool m_gameLoopInitialized = false;  // Instance variable
    // ...
};

Option 2: Atomic Protection

Protect the variable with atomic operations:

// In globals.h
#include <atomic>
extern std::atomic<bool> gameLoopInitialized;

// In mm_plugin.cpp
bool expected = false;
if (globals::gameLoopInitialized.compare_exchange_strong(expected, true)) {
    CALL_GLOBAL_LISTENER(OnGameLoopInitialized());
}

Option 3: Process Synchronization

Use a process-wide mutex/semaphore, but this is more complex and may impact performance.

Additional Notes

• Issue occurs when servers share the same CounterStrikeSharp installation directory

Reproduction Rate

Out of 5 concurrent server starts:

• 3-4 servers: initialize successfully (5-8 seconds)
• 1-2 servers: hang indefinitely

[roflmuffin]

I don't see how this is related; gameLoopInitialized is not shared across memory in each process so the RCA is just AI hallucination

[github-actions]

This issue has been marked needs-author-action and may be missing some important information.

[github-actions]

This issue has been automatically marked no-recent-activity because it has not had any activity for 14 days. It will be closed if no further activity occurs within 14 more days. Any new comment (by anyone, not necessarily the author) will remove no-recent-activity.

[github-actions]

This issue will now be closed since it had been marked no-recent-activity but received no further activity in the past 14 days.