+ learned the lesson, lock the global mutex in different other places just to be on the safe side, after lego 2k I am hesitent about all APIs, will this slow things down?

+ refactor some debug messages
2024-11-23 11:15:34 +08:00 · 2023-12-19 22:17:29 +02:00 · 2023-12-19 22:17:29 +02:00 · 4fb6dcb3fa
commit 4fb6dcb3fa
parent 1333168d4a
9 changed files with 90 additions and 35 deletions
--- a/dll/dll.cpp
+++ b/dll/dll.cpp
@ -177,6 +177,7 @@ bool steamclient_has_ipv6_functions()

 static void *create_client_interface(const char *ver)
 {
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    if (strstr(ver, "SteamClient") == ver) {
        void *steam_client;

--- a/dll/steam_apps.cpp
+++ b/dll/steam_apps.cpp
@ -165,11 +165,15 @@ bool Steam_Apps::BGetDLCDataByIndex( int iDLC, AppId_t *pAppID, bool *pbAvailabl
 void Steam_Apps::InstallDLC( AppId_t nAppID )
 {
    PRINT_DEBUG("InstallDLC\n");
+    // we lock here because the API is supposed to modify the DLC list
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
 }

 void Steam_Apps::UninstallDLC( AppId_t nAppID )
 {
    PRINT_DEBUG("UninstallDLC\n");
+    // we lock here because the API is supposed to modify the DLC list
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
 }


@ -227,7 +231,7 @@ void Steam_Apps::RequestAppProofOfPurchaseKey( AppId_t nAppID )
 bool Steam_Apps::GetCurrentBetaName( char *pchName, int cchNameBufferSize )
 {
    PRINT_DEBUG("GetCurrentBetaName %i\n", cchNameBufferSize);
-
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    if (pchName && cchNameBufferSize > settings->current_branch_name.size()) {
        memcpy(pchName, settings->current_branch_name.c_str(), settings->current_branch_name.size());
    }
@ -239,6 +243,7 @@ bool Steam_Apps::GetCurrentBetaName( char *pchName, int cchNameBufferSize )
 bool Steam_Apps::MarkContentCorrupt( bool bMissingFilesOnly )
 {
    PRINT_DEBUG("MarkContentCorrupt\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    //TODO: warn user
    return true;
 }
@ -248,8 +253,8 @@ uint32 Steam_Apps::GetInstalledDepots( AppId_t appID, DepotId_t *pvecDepots, uin
 {
    PRINT_DEBUG("GetInstalledDepots %u, %u\n", appID, cMaxDepots);
    //TODO not sure about the behavior of this function, I didn't actually test this.
-    if (!pvecDepots) return 0;
    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+    if (!pvecDepots) return 0;
    unsigned int count = settings->depots.size();
    if (cMaxDepots < count) count = cMaxDepots;
    std::copy(settings->depots.begin(), settings->depots.begin() + count, pvecDepots);
@ -319,6 +324,7 @@ bool Steam_Apps::BIsAppInstalled( AppId_t appID )
 CSteamID Steam_Apps::GetAppOwner()
 {
    PRINT_DEBUG("GetAppOwner\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return settings->get_local_steam_id();
 }

@ -337,6 +343,7 @@ const char *Steam_Apps::GetLaunchQueryParam( const char *pchKey )
 bool Steam_Apps::GetDlcDownloadProgress( AppId_t nAppID, uint64 *punBytesDownloaded, uint64 *punBytesTotal )
 {
    PRINT_DEBUG("GetDlcDownloadProgress\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return false;
 }
 
@ -345,6 +352,7 @@ bool Steam_Apps::GetDlcDownloadProgress( AppId_t nAppID, uint64 *punBytesDownloa
 int Steam_Apps::GetAppBuildId()
 {
    PRINT_DEBUG("GetAppBuildId\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return this->settings->build_id;
 }

@ -427,6 +435,7 @@ int Steam_Apps::GetLaunchCommandLine( char *pszCommandLine, int cubCommandLine )
 bool Steam_Apps::BIsSubscribedFromFamilySharing()
 {
    PRINT_DEBUG("BIsSubscribedFromFamilySharing\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return false;
 }

@ -434,6 +443,7 @@ bool Steam_Apps::BIsSubscribedFromFamilySharing()
 bool Steam_Apps::BIsTimedTrial( uint32* punSecondsAllowed, uint32* punSecondsPlayed )
 {
    PRINT_DEBUG("BIsTimedTrial\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return false;
 }

@ -441,5 +451,6 @@ bool Steam_Apps::BIsTimedTrial( uint32* punSecondsAllowed, uint32* punSecondsPla
 bool Steam_Apps::SetDlcContext( AppId_t nAppID )
 {
    PRINT_DEBUG("SetDlcContext %u\n", nAppID);
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return true;
 }
--- a/dll/steam_client.cpp
+++ b/dll/steam_client.cpp
@ -879,7 +879,7 @@ uint32 Steam_Client::GetIPCCallCount()
 // callbacks will occur directly after the API function is called that generated the warning or message.
 void Steam_Client::SetWarningMessageHook( SteamAPIWarningMessageHook_t pFunction )
 {
-    PRINT_DEBUG("Steam_Client::SetWarningMessageHook\n");
+    PRINT_DEBUG("Steam_Client::SetWarningMessageHook, %p\n", pFunction);
 }

 // Trigger global shutdown for the DLL
@ -1103,7 +1103,8 @@ void Steam_Client::DEPRECATED_Remove_SteamAPI_CPostAPIResultInProcess( void (*)(

 void Steam_Client::Set_SteamAPI_CCheckCallbackRegisteredInProcess( SteamAPI_CheckCallbackRegistered_t func )
 {
-    PRINT_DEBUG("Set_SteamAPI_CCheckCallbackRegisteredInProcess\n");
+    PRINT_DEBUG("Set_SteamAPI_CCheckCallbackRegisteredInProcess %p\n", func);
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
 }

 void Steam_Client::Set_SteamAPI_CPostAPIResultInProcess( SteamAPI_PostAPIResultInProcess_t func )
--- a/dll/steam_gameserver.cpp
+++ b/dll/steam_gameserver.cpp
@ -187,7 +187,7 @@ void Steam_GameServer::LogOff()
 // status functions
 bool Steam_GameServer::BLoggedOn()
 {
-    PRINT_DEBUG("BLoggedOn\n");
+    PRINT_DEBUG("Steam_GameServer::BLoggedOn\n");
    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return logged_in;
 }
@ -439,6 +439,7 @@ void Steam_GameServer::SendUserDisconnect( CSteamID steamIDUser )
 bool Steam_GameServer::BUpdateUserData( CSteamID steamIDUser, const char *pchPlayerName, uint32 uScore )
 {
    PRINT_DEBUG("BUpdateUserData %llu %s %u\n", steamIDUser.ConvertToUint64(), pchPlayerName, uScore);
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);

    auto player_it = std::find_if(players.begin(), players.end(), [&steamIDUser](std::pair<CSteamID, Gameserver_Player_Info_t>& player)
    {
@ -610,6 +611,7 @@ void Steam_GameServer::CancelAuthTicket( HAuthTicket hAuthTicket )
 EUserHasLicenseForAppResult Steam_GameServer::UserHasLicenseForApp( CSteamID steamID, AppId_t appID )
 {
    PRINT_DEBUG("Steam_GameServer::UserHasLicenseForApp\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return k_EUserHasLicenseResultHasLicense;
 }

@ -630,6 +632,7 @@ bool Steam_GameServer::RequestUserGroupStatus( CSteamID steamIDUser, CSteamID st
 void Steam_GameServer::GetGameplayStats( )
 {
    PRINT_DEBUG("GetGameplayStats\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
 }

 STEAM_CALL_RESULT( GSReputation_t )
--- a/dll/steam_remoteplay.h
+++ b/dll/steam_remoteplay.h
@ -66,6 +66,7 @@ Steam_RemotePlay(class Settings *settings, class Networking *network, class Stea
 uint32 GetSessionCount()
 {
    PRINT_DEBUG("Steam_RemotePlay::GetSessionCount\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return 0;
 }

@ -73,6 +74,7 @@ uint32 GetSessionCount()
 uint32 GetSessionID( int iSessionIndex )
 {
    PRINT_DEBUG("Steam_RemotePlay::GetSessionID\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return 0;
 }

@ -80,6 +82,7 @@ uint32 GetSessionID( int iSessionIndex )
 CSteamID GetSessionSteamID( uint32 unSessionID )
 {
    PRINT_DEBUG("Steam_RemotePlay::GetSessionSteamID\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return k_steamIDNil;
 }

@ -88,6 +91,7 @@ CSteamID GetSessionSteamID( uint32 unSessionID )
 const char *GetSessionClientName( uint32 unSessionID )
 {
    PRINT_DEBUG("Steam_RemotePlay::GetSessionClientName\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return NULL;
 }

@ -95,6 +99,7 @@ const char *GetSessionClientName( uint32 unSessionID )
 ESteamDeviceFormFactor GetSessionClientFormFactor( uint32 unSessionID )
 {
    PRINT_DEBUG("Steam_RemotePlay::GetSessionClientFormFactor\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return k_ESteamDeviceFormFactorUnknown;
 }

@ -112,6 +117,7 @@ bool BGetSessionClientResolution( uint32 unSessionID, int *pnResolutionX, int *p
 bool BStartRemotePlayTogether( bool bShowOverlay )
 {
    PRINT_DEBUG("Steam_RemotePlay::BStartRemotePlayTogether: %d\n", (int)bShowOverlay);
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return false;
 }

@ -120,6 +126,7 @@ bool BStartRemotePlayTogether( bool bShowOverlay )
 bool BSendRemotePlayTogetherInvite( CSteamID steamIDFriend )
 {
    PRINT_DEBUG("Steam_RemotePlay::BSendRemotePlayTogetherInvite\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return false;
 }

--- a/dll/steam_user.h
+++ b/dll/steam_user.h
@ -77,7 +77,7 @@ HSteamUser GetHSteamUser()
 // The Steam client will automatically be trying to recreate the connection as often as possible.
 bool BLoggedOn()
 {
-    PRINT_DEBUG("BLoggedOn\n");
+    PRINT_DEBUG("Steam_User::BLoggedOn\n");
    return !settings->is_offline();
 }

--- a/dll/steam_user_stats.h
+++ b/dll/steam_user_stats.h
@ -296,10 +296,11 @@ bool RequestCurrentStats()
 bool GetStat( const char *pchName, int32 *pData )
 {
    PRINT_DEBUG("GetStat int32 %s\n", pchName);
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
    if (!pchName || !pData) return false;
    std::string stat_name = ascii_to_lowercase(pchName);

-    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    auto stats_config = settings->getStats();
    auto stats_data = stats_config.find(stat_name);
    if (stats_data != stats_config.end()) {
@ -332,10 +333,11 @@ bool GetStat( const char *pchName, int32 *pData )
 bool GetStat( const char *pchName, float *pData )
 {
    PRINT_DEBUG("GetStat float %s\n", pchName);
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
    if (!pchName || !pData) return false;
    std::string stat_name = ascii_to_lowercase(pchName);

-    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    auto stats_config = settings->getStats();
    auto stats_data = stats_config.find(stat_name);
    if (stats_data != stats_config.end()) {
@ -370,10 +372,11 @@ bool GetStat( const char *pchName, float *pData )
 bool SetStat( const char *pchName, int32 nData )
 {
    PRINT_DEBUG("SetStat int32 %s\n", pchName);
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
    if (!pchName) return false;
    std::string stat_name = ascii_to_lowercase(pchName);

-    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    auto cached_stat = stats_cache_int.find(stat_name);
    if (cached_stat != stats_cache_int.end()) {
        if (cached_stat->second == nData) return true;
@ -399,10 +402,11 @@ bool SetStat( const char *pchName, int32 nData )
 bool SetStat( const char *pchName, float fData )
 {
    PRINT_DEBUG("SetStat float %s\n", pchName);
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
    if (!pchName) return false;
    std::string stat_name = ascii_to_lowercase(pchName);

-    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    auto cached_stat = stats_cache_float.find(stat_name);
    if (cached_stat != stats_cache_float.end()) {
        if (cached_stat->second == fData) return true;
@ -428,11 +432,11 @@ bool SetStat( const char *pchName, float fData )
 bool UpdateAvgRateStat( const char *pchName, float flCountThisSession, double dSessionLength )
 {
    PRINT_DEBUG("UpdateAvgRateStat %s\n", pchName);
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
    if (!pchName) return false;
    std::string stat_name = ascii_to_lowercase(pchName);

-    std::lock_guard<std::recursive_mutex> lock(global_mutex);
-
    char data[sizeof(float) + sizeof(float) + sizeof(double)];
    int read_data = local_storage->get_data(Local_Storage::stats_storage_folder, stat_name, (char* )data, sizeof(*data));
    float oldcount = 0;
@ -463,9 +467,10 @@ bool UpdateAvgRateStat( const char *pchName, float flCountThisSession, double dS
 bool GetAchievement( const char *pchName, bool *pbAchieved )
 {
    PRINT_DEBUG("GetAchievement %s\n", pchName);
-    if (pchName == nullptr) return false;
    std::lock_guard<std::recursive_mutex> lock(global_mutex);

+    if (pchName == nullptr) return false;
+
    try {
        auto it = defined_achievements_find(pchName);
        if (it == defined_achievements.end()) return false;
@ -486,12 +491,12 @@ bool GetAchievement( const char *pchName, bool *pbAchieved )
 bool SetAchievement( const char *pchName )
 {
    PRINT_DEBUG("SetAchievement %s\n", pchName);
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
    if (pchName == nullptr) return false;
    
    if (settings->achievement_bypass) return true;

-    std::lock_guard<std::recursive_mutex> lock(global_mutex);
-
    try {
        auto it = defined_achievements_find(pchName);
        if (it == defined_achievements.end()) return false;
@ -517,9 +522,10 @@ bool SetAchievement( const char *pchName )
 bool ClearAchievement( const char *pchName )
 {
    PRINT_DEBUG("ClearAchievement %s\n", pchName);
-    if (pchName == nullptr) return false;
    std::lock_guard<std::recursive_mutex> lock(global_mutex);

+    if (pchName == nullptr) return false;
+
    try {
        auto it = defined_achievements_find(pchName);
        if (it == defined_achievements.end()) return false;
@ -543,9 +549,10 @@ bool ClearAchievement( const char *pchName )
 bool GetAchievementAndUnlockTime( const char *pchName, bool *pbAchieved, uint32 *punUnlockTime )
 {
    PRINT_DEBUG("GetAchievementAndUnlockTime\n");
-    if (pchName == nullptr) return false;
    std::lock_guard<std::recursive_mutex> lock(global_mutex);

+    if (pchName == nullptr) return false;
+
    try {
        auto it = defined_achievements_find(pchName);
        if (it == defined_achievements.end()) return false;
@ -594,16 +601,16 @@ bool StoreStats()
 int GetAchievementIcon( const char *pchName )
 {
    PRINT_DEBUG("GetAchievementIcon\n");
-    if (pchName == nullptr) return 0;
    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+    if (pchName == nullptr) return 0;

    return 0;
 }

 std::string get_achievement_icon_name( const char *pchName, bool pbAchieved )
 {
-    if (pchName == nullptr) return "";
    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+    if (pchName == nullptr) return "";

    try {
        auto it = defined_achievements_find(pchName);
@ -623,10 +630,11 @@ std::string get_achievement_icon_name( const char *pchName, bool pbAchieved )
 const char * GetAchievementDisplayAttribute( const char *pchName, const char *pchKey )
 {
    PRINT_DEBUG("GetAchievementDisplayAttribute %s %s\n", pchName, pchKey);
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+
    if (pchName == nullptr) return "";
    if (pchKey == nullptr) return "";

-    std::lock_guard<std::recursive_mutex> lock(global_mutex);

    if (strcmp (pchKey, "name") == 0) {
        try {
@ -664,9 +672,10 @@ const char * GetAchievementDisplayAttribute( const char *pchName, const char *pc
 bool IndicateAchievementProgress( const char *pchName, uint32 nCurProgress, uint32 nMaxProgress )
 {
    PRINT_DEBUG("IndicateAchievementProgress %s\n", pchName);
-    if (pchName == nullptr) return false;
    std::lock_guard<std::recursive_mutex> lock(global_mutex);

+    if (pchName == nullptr) return false;
+
    try {
        auto it = defined_achievements_find(pchName);
        if (it == defined_achievements.end()) return false;
@ -718,6 +727,7 @@ uint32 GetNumAchievements()
 const char * GetAchievementName( uint32 iAchievement )
 {
    PRINT_DEBUG("GetAchievementName\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    if (iAchievement >= sorted_achievement_names.size()) {
        return "";
    }
@ -756,10 +766,10 @@ SteamAPICall_t RequestUserStats( CSteamID steamIDUser )
 bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData )
 {
    PRINT_DEBUG("GetUserStat %s %llu\n", pchName, steamIDUser.ConvertToUint64());
-    if (pchName == nullptr) return false;
-
    std::lock_guard<std::recursive_mutex> lock(global_mutex);

+    if (pchName == nullptr) return false;
+
    if (steamIDUser == settings->get_local_steam_id()) {
        GetStat(pchName, pData);
    } else {
@ -772,10 +782,10 @@ bool GetUserStat( CSteamID steamIDUser, const char *pchName, int32 *pData )
 bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData )
 {
    PRINT_DEBUG("GetUserStat %s %llu\n", pchName, steamIDUser.ConvertToUint64());
-    if (pchName == nullptr) return false;
-
    std::lock_guard<std::recursive_mutex> lock(global_mutex);

+    if (pchName == nullptr) return false;
+
    if (steamIDUser == settings->get_local_steam_id()) {
        GetStat(pchName, pData);
    } else {
@ -788,8 +798,9 @@ bool GetUserStat( CSteamID steamIDUser, const char *pchName, float *pData )
 bool GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchieved )
 {
    PRINT_DEBUG("GetUserAchievement %s\n", pchName);
-    if (pchName == nullptr) return false;
    std::lock_guard<std::recursive_mutex> lock(global_mutex);
+    
+    if (pchName == nullptr) return false;

    if (steamIDUser == settings->get_local_steam_id()) {
        return GetAchievement(pchName, pbAchieved);
@ -802,9 +813,10 @@ bool GetUserAchievement( CSteamID steamIDUser, const char *pchName, bool *pbAchi
 bool GetUserAchievementAndUnlockTime( CSteamID steamIDUser, const char *pchName, bool *pbAchieved, uint32 *punUnlockTime )
 {
    PRINT_DEBUG("GetUserAchievementAndUnlockTime %s\n", pchName);
-    if (pchName == nullptr) return false;
    std::lock_guard<std::recursive_mutex> lock(global_mutex);

+    if (pchName == nullptr) return false;
+
    if (steamIDUser == settings->get_local_steam_id()) {
        return GetAchievementAndUnlockTime(pchName, pbAchieved, punUnlockTime);
    }
@ -965,7 +977,7 @@ SteamAPICall_t DownloadLeaderboardEntries( SteamLeaderboard_t hSteamLeaderboard,
 // if a user doesn't have a leaderboard entry, they won't be included in the result
 // a max of 100 users can be downloaded at a time, with only one outstanding call at a time
 STEAM_METHOD_DESC(Downloads leaderboard entries for an arbitrary set of users - ELeaderboardDataRequest is k_ELeaderboardDataRequestUsers)
-    STEAM_CALL_RESULT( LeaderboardScoresDownloaded_t )
+STEAM_CALL_RESULT( LeaderboardScoresDownloaded_t )
 SteamAPICall_t DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLeaderboard,
                                                            STEAM_ARRAY_COUNT_D(cUsers, Array of users to retrieve) CSteamID *prgUsers, int cUsers )
 {
--- a/dll/steam_utils.h
+++ b/dll/steam_utils.h
@ -89,9 +89,10 @@ const char *GetIPCountry()
 bool GetImageSize( int iImage, uint32 *pnWidth, uint32 *pnHeight )
 {
    PRINT_DEBUG("GetImageSize %i\n", iImage);
-    if (!iImage || !pnWidth || !pnHeight) return false;
    std::lock_guard<std::recursive_mutex> lock(global_mutex);

+    if (!iImage || !pnWidth || !pnHeight) return false;
+
    auto image = settings->images.find(iImage);
    if (image == settings->images.end()) return false;

@ -106,9 +107,10 @@ bool GetImageSize( int iImage, uint32 *pnWidth, uint32 *pnHeight )
 bool GetImageRGBA( int iImage, uint8 *pubDest, int nDestBufferSize )
 {
    PRINT_DEBUG("GetImageRGBA %i\n", iImage);
-    if (!iImage || !pubDest || !nDestBufferSize) return false;
    std::lock_guard<std::recursive_mutex> lock(global_mutex);

+    if (!iImage || !pubDest || !nDestBufferSize) return false;
+
    auto image = settings->images.find(iImage);
    if (image == settings->images.end()) return false;

@ -138,6 +140,7 @@ uint8 GetCurrentBatteryPower()
 uint32 GetAppID()
 {
    PRINT_DEBUG("GetAppID\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return settings->get_local_game_id().AppID();
 }

@ -147,6 +150,7 @@ uint32 GetAppID()
 void SetOverlayNotificationPosition( ENotificationPosition eNotificationPosition )
 {
    PRINT_DEBUG("SetOverlayNotificationPosition\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    overlay->SetNotificationPosition(eNotificationPosition);
 }

@ -156,12 +160,12 @@ void SetOverlayNotificationPosition( ENotificationPosition eNotificationPosition
 bool IsAPICallCompleted( SteamAPICall_t hSteamAPICall, bool *pbFailed )
 {
    PRINT_DEBUG("IsAPICallCompleted: %llu\n", hSteamAPICall);
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    if (hSteamAPICall == 1) { //bug ? soul calibur 6 calls this function with the return value 1 of Steam_User_Stats::RequestCurrentStats and expects this function to return true
        if (pbFailed) *pbFailed = true;
        return true;
    }

-    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    if (!callback_results->exists(hSteamAPICall)) return false;
    if (pbFailed) *pbFailed = false;
    return true; //all api calls "complete" right away
@ -222,6 +226,7 @@ void SetWarningMessageHook( SteamAPIWarningMessageHook_t pFunction )
 bool IsOverlayEnabled()
 {
    PRINT_DEBUG("IsOverlayEnabled\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return overlay->Ready();
 }

@ -238,6 +243,7 @@ bool IsOverlayEnabled()
 bool BOverlayNeedsPresent()
 {
    PRINT_DEBUG("BOverlayNeedsPresent\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return overlay->NeedPresent();
 }

@ -271,6 +277,7 @@ bool ShowGamepadTextInput( EGamepadTextInputMode eInputMode, EGamepadTextInputLi
 bool ShowGamepadTextInput( EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32 unCharMax )
 {
 	PRINT_DEBUG("ShowGamepadTextInput old\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
 	return ShowGamepadTextInput(eInputMode, eLineInputMode, pchDescription, unCharMax, NULL);
 }

@ -292,6 +299,7 @@ bool GetEnteredGamepadTextInput( char *pchText, uint32 cchText )
 const char *GetSteamUILanguage()
 {
    PRINT_DEBUG("GetSteamUILanguage\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return settings->get_language();
 }

@ -300,6 +308,7 @@ const char *GetSteamUILanguage()
 bool IsSteamRunningInVR()
 {
    PRINT_DEBUG("IsSteamRunningInVR\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return false;
 }

@ -308,6 +317,7 @@ bool IsSteamRunningInVR()
 void SetOverlayNotificationInset( int nHorizontalInset, int nVerticalInset )
 {
    PRINT_DEBUG("SetOverlayNotificationInset\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    overlay->SetNotificationInset(nHorizontalInset, nVerticalInset);
 }

@ -318,6 +328,7 @@ void SetOverlayNotificationInset( int nHorizontalInset, int nVerticalInset )
 bool IsSteamInBigPictureMode()
 {
    PRINT_DEBUG("IsSteamInBigPictureMode\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return false;
 }

@ -333,6 +344,7 @@ void StartVRDashboard()
 bool IsVRHeadsetStreamingEnabled()
 {
    PRINT_DEBUG("IsVRHeadsetStreamingEnabled\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return false;
 }

@ -351,6 +363,7 @@ void SetVRHeadsetStreamingEnabled( bool bEnabled )
 bool IsSteamChinaLauncher()
 {
    PRINT_DEBUG("IsSteamChinaLauncher\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return false;
 }

@ -359,6 +372,7 @@ bool IsSteamChinaLauncher()
 bool InitFilterText()
 {
    PRINT_DEBUG("InitFilterText old\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return false;
 }

@ -368,6 +382,7 @@ bool InitFilterText()
 bool InitFilterText( uint32 unFilterOptions )
 {
    PRINT_DEBUG("InitFilterText\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return false;
 }

@ -380,6 +395,7 @@ bool InitFilterText( uint32 unFilterOptions )
 int FilterText( char* pchOutFilteredText, uint32 nByteSizeOutFilteredText, const char * pchInputMessage, bool bLegalOnly )
 {
    PRINT_DEBUG("FilterText old\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return FilterText(k_ETextFilteringContextUnknown, CSteamID(), pchInputMessage, pchOutFilteredText, nByteSizeOutFilteredText );
 }

@ -393,6 +409,7 @@ int FilterText( char* pchOutFilteredText, uint32 nByteSizeOutFilteredText, const
 int FilterText( ETextFilteringContext eContext, CSteamID sourceSteamID, const char *pchInputMessage, char *pchOutFilteredText, uint32 nByteSizeOutFilteredText )
 {
    PRINT_DEBUG("FilterText\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    if (!nByteSizeOutFilteredText) return 0;
    unsigned len = strlen(pchInputMessage);
    if (!len) return 0;
@ -411,6 +428,7 @@ int FilterText( ETextFilteringContext eContext, CSteamID sourceSteamID, const ch
 ESteamIPv6ConnectivityState GetIPv6ConnectivityState( ESteamIPv6ConnectivityProtocol eProtocol )
 {
    PRINT_DEBUG("GetIPv6ConnectivityState\n");
+    std::lock_guard<std::recursive_mutex> lock(global_mutex);
    return k_ESteamIPv6ConnectivityState_Unknown;
 }

--- a/overlay_experimental/steam_overlay.cpp
+++ b/overlay_experimental/steam_overlay.cpp
@ -210,6 +210,8 @@ void Steam_Overlay::SetupOverlay()

 void Steam_Overlay::UnSetupOverlay()
 {
+    PRINT_DEBUG("%s\n", __FUNCTION__);
+    std::lock_guard<std::recursive_mutex> lock(overlay_mutex);
    ingame_overlay::StopRendererDetection();
    if (!Ready() && future_renderer.valid()) {
        if (future_renderer.wait_for(std::chrono::milliseconds{500}) ==  std::future_status::ready) {
@ -358,10 +360,10 @@ void Steam_Overlay::NotifyUserAchievement()

 void Steam_Overlay::SetLobbyInvite(Friend friendId, uint64 lobbyId)
 {
+    std::lock_guard<std::recursive_mutex> lock(overlay_mutex);
    if (!Ready())
        return;

-    std::lock_guard<std::recursive_mutex> lock(overlay_mutex);
    auto i = friends.find(friendId);
    if (i != friends.end())
    {
@ -377,10 +379,10 @@ void Steam_Overlay::SetLobbyInvite(Friend friendId, uint64 lobbyId)

 void Steam_Overlay::SetRichInvite(Friend friendId, const char* connect_str)
 {
+    std::lock_guard<std::recursive_mutex> lock(overlay_mutex);
    if (!Ready())
        return;

-    std::lock_guard<std::recursive_mutex> lock(overlay_mutex);
    auto i = friends.find(friendId);
    if (i != friends.end())
    {
@ -421,8 +423,8 @@ void Steam_Overlay::FriendDisconnect(Friend _friend)

 void Steam_Overlay::AddMessageNotification(std::string const& message)
 {
-    if (settings->disable_overlay_friend_notification) return;
    std::lock_guard<std::recursive_mutex> lock(notifications_mutex);
+    if (settings->disable_overlay_friend_notification) return;
    int id = find_free_notification_id(notifications);
    if (id != 0)
    {
@ -487,8 +489,8 @@ void Steam_Overlay::AddAchievementNotification(nlohmann::json const& ach)

 void Steam_Overlay::AddInviteNotification(std::pair<const Friend, friend_window_state>& wnd_state)
 {
-    if (settings->disable_overlay_friend_notification) return;
    std::lock_guard<std::recursive_mutex> lock(notifications_mutex);
+    if (settings->disable_overlay_friend_notification) return;
    int id = find_free_notification_id(notifications);
    if (id != 0)
    {