Merge branch 'release/2026.01' into project/voice_moderation

Author: maxim-productengine

indra/llcommon/CMakeLists.txt

@@ -101,6 +101,7 @@ set(llcommon_SOURCE_FILES
     lluri.cpp
     lluriparser.cpp
     lluuid.cpp
+    llwatchdog.cpp
     llworkerthread.cpp
     hbxxh.cpp
     u64.cpp
@@ -240,6 +241,7 @@ set(llcommon_HEADER_FILES
     lluri.h
     lluriparser.h
     lluuid.h
+    llwatchdog.h
     llwin32headers.h
     llworkerthread.h
     hbxxh.h

indra/llcommon/lleventcoro.cpp

@@ -137,6 +137,18 @@ void llcoro::suspendUntilTimeout(float seconds)
     suspendUntilEventOnWithTimeout(bogus, seconds, timedout);
 }
 
+void llcoro::suspendUntilNextFrame()
+{
+    LLCoros::checkStop();
+    LLCoros::TempStatus st("waiting for next frame");
+
+    // Listen for the next event on the "mainloop" event pump.
+    // Once per frame we get mainloop.post(newFrame);
+    LLEventPumpOrPumpName mainloop_pump("mainloop");
+    // Wait for the next event (the event data is ignored).
+    suspendUntilEventOn(mainloop_pump);
+}
+
 namespace
 {
 

indra/llcommon/lleventcoro.h

@@ -84,6 +84,11 @@ void suspend();
  */
 void suspendUntilTimeout(float seconds);
 
+/**
+ * Yield control from a coroutine until the next mainloop's newFrame event.
+ */
+void suspendUntilNextFrame();
+
 /**
  * Post specified LLSD event on the specified LLEventPump, then suspend for a
  * response on specified other LLEventPump. This is more than mere

indra/llcommon/llthread.cpp

@@ -240,7 +240,11 @@ void LLThread::tryRun()
         LL::WorkQueue::ptr_t main_queue = LL::WorkQueue::getInstance("mainloop");
         main_queue->post(
             // Bind the current exception, rethrow it in main loop.
-            [exc = std::current_exception()]() { std::rethrow_exception(exc); });
+            [exc = std::current_exception(), name = mName]()
+        {
+            LL_INFOS("THREAD") << "Rethrowing exception from thread " << name << LL_ENDL;
+            std::rethrow_exception(exc);
+        });
     }
 #endif // else LL_WINDOWS
 }

indra/newview/llwatchdog.cpp indra/llcommon/llwatchdog.cppindra/newview/llwatchdog.cpp renamed to indra/llcommon/llwatchdog.cpp

@@ -24,11 +24,11 @@
  * $/LicenseInfo$
  */
 
+// Precompiled header
+#include "linden_common.h"
 
-#include "llviewerprecompiledheaders.h"
 #include "llwatchdog.h"
 #include "llthread.h"
-#include "llappviewer.h"
 
 constexpr U32 WATCHDOG_SLEEP_TIME_USEC = 1000000U;
 
@@ -67,7 +67,9 @@ class LLWatchdogTimerThread : public LLThread
 };
 
 // LLWatchdogEntry
-LLWatchdogEntry::LLWatchdogEntry()
+LLWatchdogEntry::LLWatchdogEntry(const std::string& thread_name)
+    : mThreadName(thread_name)
+    , mThreadID(LLThread::currentID())
 {
 }
 
@@ -89,11 +91,16 @@ void LLWatchdogEntry::stop()
         LLWatchdog::getInstance()->remove(this);
     }
 }
+std::string LLWatchdogEntry::getThreadName() const
+{
+    return mThreadName + llformat(": %d", mThreadID);
+}
 
 // LLWatchdogTimeout
 const std::string UNINIT_STRING = "uninitialized";
 
-LLWatchdogTimeout::LLWatchdogTimeout() :
+LLWatchdogTimeout::LLWatchdogTimeout(const std::string& thread_name) :
+    LLWatchdogEntry(thread_name),
     mTimeout(0.0f),
     mPingState(UNINIT_STRING)
 {
@@ -175,7 +182,7 @@ void LLWatchdog::remove(LLWatchdogEntry* e)
     unlockThread();
 }
 
-void LLWatchdog::init()
+void LLWatchdog::init(func_t set_error_state_callback)
 {
     if (!mSuspectsAccessMutex && !mTimer)
     {
@@ -188,6 +195,7 @@ void LLWatchdog::init()
         // start needs to use the mSuspectsAccessMutex
         mTimer->start();
     }
+    mCreateMarkerFnc = set_error_state_callback;
 }
 
 void LLWatchdog::cleanup()
@@ -241,17 +249,23 @@ void LLWatchdog::run()
             {
                 mTimer->stop();
             }
-            if (LLAppViewer::instance()->logoutRequestSent())
+
+            // Sets error marker file
+            mCreateMarkerFnc();
+            // Todo1: Warn user?
+            // Todo2: We probably want to report even if 5 seconds passed, just not error 'yet'.
+            std::string last_state = (*result)->getLastState();
+            if (last_state.empty())
             {
-                LLAppViewer::instance()->createErrorMarker(LAST_EXEC_LOGOUT_FROZE);
+                LL_ERRS() << "Watchdog timer for thread " << (*result)->getThreadName()
+                    << " expired; assuming viewer is hung and crashing" << LL_ENDL;
             }
             else
             {
-                LLAppViewer::instance()->createErrorMarker(LAST_EXEC_FROZE);
+                LL_ERRS() << "Watchdog timer for thread " << (*result)->getThreadName()
+                    << " expired with state: " << last_state
+                    << "; assuming viewer is hung and crashing" << LL_ENDL;
             }
-            // Todo1: warn user?
-            // Todo2: We probably want to report even if 5 seconds passed, just not error 'yet'.
-            LL_ERRS() << "Watchdog timer expired; assuming viewer is hung and crashing" << LL_ENDL;
         }
     }
 

indra/newview/llwatchdog.h indra/llcommon/llwatchdog.hindra/newview/llwatchdog.h renamed to indra/llcommon/llwatchdog.h

@@ -30,13 +30,17 @@
 #ifndef LL_TIMER_H
     #include "lltimer.h"
 #endif
+#include "llmutex.h"
+#include "llsingleton.h"
+
+#include <functional>
 
 // LLWatchdogEntry is the interface used by the tasks that
 // need to be watched.
 class LLWatchdogEntry
 {
 public:
-    LLWatchdogEntry();
+    LLWatchdogEntry(const std::string &thread_name);
     virtual ~LLWatchdogEntry();
 
     // isAlive is accessed by the watchdog thread.
@@ -46,12 +50,19 @@ class LLWatchdogEntry
     virtual void reset() = 0;
     virtual void start();
     virtual void stop();
+    virtual std::string getLastState() const { return std::string(); }
+    typedef std::thread::id id_t;
+    std::string getThreadName() const;
+
+private:
+    id_t mThreadID; // ID of the thread being watched
+    std::string mThreadName;
 };
 
 class LLWatchdogTimeout : public LLWatchdogEntry
 {
 public:
-    LLWatchdogTimeout();
+    LLWatchdogTimeout(const std::string& thread_name);
     virtual ~LLWatchdogTimeout();
 
     bool isAlive() const override;
@@ -63,6 +74,7 @@ class LLWatchdogTimeout : public LLWatchdogEntry
     void setTimeout(F32 d);
     void ping(std::string_view state);
     const std::string& getState() {return mPingState; }
+    std::string getLastState() const override { return mPingState; }
 
 private:
     LLTimer mTimer;
@@ -81,10 +93,12 @@ class LLWatchdog : public LLSingleton<LLWatchdog>
     void add(LLWatchdogEntry* e);
     void remove(LLWatchdogEntry* e);
 
-    void init();
+    typedef std::function<void()> func_t;
+    void init(func_t set_error_state_callback);
     void run();
     void cleanup();
 
+
 private:
     void lockThread();
     void unlockThread();
@@ -94,6 +108,11 @@ class LLWatchdog : public LLSingleton<LLWatchdog>
     LLMutex* mSuspectsAccessMutex;
     LLWatchdogTimerThread* mTimer;
     U64 mLastClockCount;
+
+    // At the moment watchdog expects app to set markers in mCreateMarkerFnc,
+    // but technically can be used to set any error states or do some cleanup
+    // or show warnings.
+    func_t mCreateMarkerFnc;
 };
 
 #endif // LL_LLTHREADWATCHDOG_H

indra/llcommon/workqueue.cpp

@@ -216,10 +216,15 @@ void LL::WorkQueueBase::callWork(const Work& work)
             LL_WARNS("LLCoros") << "Capturing and rethrowing uncaught exception in WorkQueueBase "
                                 << getKey() << LL_ENDL;
 
+            std::string name = getKey();
             LL::WorkQueue::ptr_t main_queue = LL::WorkQueue::getInstance("mainloop");
             main_queue->post(
                              // Bind the current exception, rethrow it in main loop.
-                             [exc = std::current_exception()]() { std::rethrow_exception(exc); });
+                             [exc = std::current_exception(), name]()
+            {
+                LL_INFOS("LLCoros") << "Rethrowing exception from WorkQueueBase::callWork " << name << LL_ENDL;
+                std::rethrow_exception(exc);
+            });
         }
         else
         {

indra/llcommon/workqueue.h

@@ -530,7 +530,11 @@ namespace LL
                         reply,
                         // Bind the current exception to transport back to the
                         // originating WorkQueue. Once there, rethrow it.
-                        [exc = std::current_exception()](){ std::rethrow_exception(exc); });
+                        [exc = std::current_exception()]()
+                    {
+                        LL_INFOS("LLCoros") << "Rethrowing exception from WorkQueueBase::postTo" << LL_ENDL;
+                        std::rethrow_exception(exc);
+                    });
                 }
             },
             // if caller passed a TimePoint, pass it along to post()

indra/llimage/llimage.cpp

@@ -709,8 +709,20 @@ U8* LLImageBase::allocateData(S32 size)
         mData = (U8*)ll_aligned_malloc_16(size);
         if (!mData)
         {
-            LL_WARNS() << "Failed to allocate image data size [" << size << "]" << LL_ENDL;
-            mBadBufferAllocation = true;
+            constexpr S32 MAX_TOLERANCE = 1024 * 1024 * 4; // 4 MB
+            if (size > MAX_TOLERANCE)
+            {
+                // If a big image failed to allocate, tollerate it for now.
+                // It's insightfull when crash logs without obvious cause are being analyzed,
+                // so a crash in a random location that normally is a mystery can get proper handling.
+                LL_WARNS() << "Failed to allocate image data size [" << size << "]" << LL_ENDL;
+            }
+            else
+            {
+                // We are too far gone if we can't allocate a small buffer.
+                LLError::LLUserWarningMsg::showOutOfMemory();
+                LL_ERRS() << "Failed to allocate image data size [" << size << "]" << LL_ENDL;
+            }
         }
     }
 

indra/llmessage/llassetstorage.cpp

@@ -1316,6 +1316,9 @@ const char* LLAssetStorage::getErrorString(S32 status)
         case LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE:
             return "Asset request: asset not found in database";
 
+        case LL_ERR_NO_CAP:
+            return "Asset request: region or asset capability not available";
+
         case LL_ERR_EOF:
             return "End of file";