Merge branch 'geenz/linux-to-develop' into marchcat/lua-linux-develop

# Conflicts:
#	.github/workflows/build.yaml
#	indra/llinventory/llinventory.cpp
#	indra/newview/CMakeLists.txt
#	indra/newview/llappviewer.cpp
#	indra/newview/llappviewerwin32.cpp
#	indra/newview/llviewermenu.cpp
#	indra/newview/llvoiceclient.cpp
#	indra/newview/skins/default/xui/en/floater_preferences_graphics_advanced.xml

1 files changed, 70 insertions, 20 deletions

diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index d8a620cf5b..9f7c244fe9 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -1085,7 +1085,14 @@ void LLShaderMgr::persistShaderCacheMetadata()
         return;
     }
 
-    LL_INFOS("ShaderMgr") << "Persisting shader cache metadata to disk" << LL_ENDL;
+    if (mShaderCacheDir.empty() || !LLFile::isdir(mShaderCacheDir))
+    {
+        LL_WARNS("ShaderMgr") << "Invalid shader cache directory: " << mShaderCacheDir << LL_ENDL;
+        return;
+    }
+
+    size_t total_entries = mShaderBinaryCache.size();
+    LL_INFOS("ShaderMgr") << "Persisting shader " << (S32)total_entries << " cache metadata entries to disk" << LL_ENDL;
 
     LLSD out;
     // Settings and shader cache get saved at different time, thus making
@@ -1096,6 +1103,8 @@ void LLShaderMgr::persistShaderCacheMetadata()
     out["shaders"] = LLSD::emptyMap();
     LLSD &shaders = out["shaders"];
 
+    size_t removed = 0;
+
     static const F32 LRU_TIME = (60.f * 60.f) * 24.f * 7.f; // 14 days
     const F32 current_time = (F32)LLTimer::getTotalSeconds();
     for (auto it = mShaderBinaryCache.begin(); it != mShaderBinaryCache.end();)
@@ -1104,8 +1113,9 @@ void LLShaderMgr::persistShaderCacheMetadata()
         if ((shader_metadata.mLastUsedTime + LRU_TIME) < current_time)
         {
             std::string shader_path = gDirUtilp->add(mShaderCacheDir, it->first.asString() + ".shaderbin");
-            LLFile::remove(shader_path);
+            LLFile::remove(shader_path, ENOENT);
             it = mShaderBinaryCache.erase(it);
+            removed++;
         }
         else
         {
@@ -1119,14 +1129,32 @@ void LLShaderMgr::persistShaderCacheMetadata()
     }
 
     std::string meta_out_path = gDirUtilp->add(mShaderCacheDir, "shaderdata.llsd");
+    if (shaders.size() == 0)
+    {
+        LL_WARNS("ShaderMgr") << "No shader cache entries to persist, removing cache metadata file" << LL_ENDL;
+        LLFile::remove(meta_out_path);
+        return;
+    }
+
     llofstream outstream(meta_out_path, std::ios_base::out | std::ios_base::binary);
     if (!outstream.is_open())
     {
         LL_WARNS("ShaderMgr") << "Failed to open file. Unable to save shader cache to: " << mShaderCacheDir << LL_ENDL;
         return;
     }
+
     LLSDSerialize::toBinary(out, outstream);
+    if (outstream.fail())
+    {
+        LL_WARNS("ShaderMgr") << "Failed to serialize shader cache metadata" << LL_ENDL;
+        outstream.close();
+        LLFile::remove(meta_out_path); // Clean up partial write
+        return;
+    }
     outstream.close();
+
+    LL_INFOS("ShaderMgr") << "Persisted " << (S32)shaders.size()
+        << " entries. Removed " << (S32)removed << " entries." << LL_ENDL;
 }
 
 bool LLShaderMgr::loadCachedProgramBinary(LLGLSLShader* shader)
@@ -1140,34 +1168,56 @@ bool LLShaderMgr::loadCachedProgramBinary(LLGLSLShader* shader)
     {
         std::string in_path = gDirUtilp->add(mShaderCacheDir, shader->mShaderHash.asString() + ".shaderbin");
         auto& shader_info = binary_iter->second;
-        if (shader_info.mBinaryLength > 0)
+
+        try
         {
-            std::vector<U8> in_data;
-            in_data.resize(shader_info.mBinaryLength);
-            std::error_code ec;
-            LLFile filep = LLFile(in_path, LLFile::in | LLFile::binary, ec);
-            if (!ec && (bool)filep)
+            constexpr GLsizei MAX_SHADER_BINARY_SIZE = 1024 * 1024; // 1 MB, normally around 10KB
+            if (shader_info.mBinaryLength > 0 && shader_info.mBinaryLength <= MAX_SHADER_BINARY_SIZE)
             {
-                size_t result = filep.read(in_data.data(), in_data.size(), ec);
-                filep.close();
+                std::vector<U8> in_data;
+                in_data.resize(shader_info.mBinaryLength);
 
-                if (result == in_data.size())
+                std::error_code ec;
+                LLFile filep = LLFile(in_path, LLFile::in | LLFile::binary, ec);
+                if (!ec && (bool)filep)
                 {
-                    GLenum error = glGetError(); // Clear current error
-                    glProgramBinary(shader->mProgramObject, shader_info.mBinaryFormat, in_data.data(), shader_info.mBinaryLength);
+                    size_t result = filep.read(in_data.data(), in_data.size(), ec);
+                    filep.close();
+
+                    if (result == in_data.size())
+                    {
+                        GLenum error = glGetError(); // Clear current error
+                        glProgramBinary(shader->mProgramObject, shader_info.mBinaryFormat, in_data.data(), shader_info.mBinaryLength);
 
-                    error = glGetError();
-                    GLint success = GL_TRUE;
-                    glGetProgramiv(shader->mProgramObject, GL_LINK_STATUS, &success);
-                    if (error == GL_NO_ERROR && success == GL_TRUE)
+                        error = glGetError();
+                        GLint success = GL_TRUE;
+                        glGetProgramiv(shader->mProgramObject, GL_LINK_STATUS, &success);
+                        if (error == GL_NO_ERROR && success == GL_TRUE)
+                        {
+                            binary_iter->second.mLastUsedTime = (F32)LLTimer::getTotalSeconds();
+                            LL_INFOS() << "Loaded cached binary for shader: " << shader->mName << LL_ENDL;
+                            return true;
+                        }
+                    }
+                    else
                     {
-                        binary_iter->second.mLastUsedTime = (F32)LLTimer::getTotalSeconds();
-                        LL_INFOS() << "Loaded cached binary for shader: " << shader->mName << LL_ENDL;
-                        return true;
+                        LL_WARNS("ShaderMgr") << "Incomplete read of shader binary. Expected: "
+                            << in_data.size() << ", read: " << result << LL_ENDL;
                     }
                 }
             }
         }
+        catch (const std::bad_alloc&)
+        {
+            LL_WARNS("ShaderMgr") << "Failed to allocate memory for shader binary ("
+                << shader_info.mBinaryLength << " bytes) for: "
+                << shader->mName << LL_ENDL;
+        }
+        catch (const std::exception& err)
+        {
+            LL_WARNS("ShaderMgr") << "Caught exception " << err.what() << " while loading shader binary for: " << shader->mName << LL_ENDL;
+        }
+
         //an error occured, normally we would print log but in this case it means the shader needs recompiling.
         LL_INFOS() << "Failed to load cached binary for shader: " << shader->mName << " falling back to compilation" << LL_ENDL;
         LLFile::remove(in_path);