14 files changed, 461 insertions, 369 deletions

diff --git a/indra/llcommon/CMakeLists.txt b/indra/llcommon/CMakeLists.txt
index 78bfaade55..aa8810f00b 100644
--- a/indra/llcommon/CMakeLists.txt
+++ b/indra/llcommon/CMakeLists.txt
@@ -70,6 +70,7 @@ set(llcommon_SOURCE_FILES
     llmetrics.cpp
     llmortician.cpp
     llmutex.cpp
+    llpointer.cpp
     llpredicate.cpp
     llprocess.cpp
     llprocessor.cpp
diff --git a/indra/llcommon/coro_scheduler.cpp b/indra/llcommon/coro_scheduler.cpp
index 2d8b6e1a97..b6117fa6a1 100644
--- a/indra/llcommon/coro_scheduler.cpp
+++ b/indra/llcommon/coro_scheduler.cpp
@@ -20,6 +20,7 @@
 #include <boost/fiber/operations.hpp>
 // other Linden headers
 #include "llcallbacklist.h"
+#include "llcoros.h"
 #include "lldate.h"
 #include "llerror.h"
 
@@ -56,17 +57,55 @@ void scheduler::awakened( boost::fibers::context* ctx) noexcept
 
 boost::fibers::context* scheduler::pick_next() noexcept
 {
+    auto now = LLDate::now().secondsSinceEpoch();
     // count calls to pick_next()
     ++mSwitches;
     // pick_next() is called when the previous fiber has suspended, and we
     // need to pick another. Did the previous pick_next() call pick the main
-    // fiber? If so, it's the main fiber that just suspended.
-    auto now = LLDate::now().secondsSinceEpoch();
-    if (mMainRunning)
+    // fiber? (Or is this the first pick_next() call?) If so, it's the main
+    // fiber that just suspended.
+    if ((! mPrevCtx) || mPrevCtx->get_id() == mMainID)
     {
-        mMainRunning = false;
         mMainLast = now;
     }
+    else
+    {
+        // How long did we spend in the fiber that just suspended?
+        // Don't bother with long runs of the main fiber, since (a) it happens
+        // pretty often and (b) it's moderately likely that we've reached here
+        // from the canonical yield at the top of mainloop, and what we'd want
+        // to know about is whatever the main fiber was doing in the
+        // *previous* iteration of mainloop.
+        F64 elapsed{ now - mResumeTime };
+        LLCoros::CoroData& data{ LLCoros::get_CoroData(mPrevCtx->get_id()) };
+        // Find iterator to the first mHistogram key greater than elapsed.
+        auto past = data.mHistogram.upper_bound(elapsed);
+        // If the smallest key (mHistogram.begin()->first) is greater than
+        // elapsed, then we need not bother with this timeslice.
+        if (past != data.mHistogram.begin())
+        {
+            // Here elapsed was greater than at least one key. Back off to the
+            // previous entry and increment that count. If it's end(), backing
+            // off gets us the last entry -- assuming mHistogram isn't empty.
+            llassert(! data.mHistogram.empty());
+            ++(--past)->second;
+            LL::WorkQueue::ptr_t queue{ getWorkQueue() };
+            // make sure the queue exists
+            if (queue)
+            {
+                // If it proves difficult to track down *why* the fiber spent so
+                // much time, consider also binding and reporting
+                // boost::stacktrace::stacktrace().
+                queue->post(
+                    [name=data.getName(), elapsed]
+                    {
+                        LL_WARNS_ONCE("LLCoros.scheduler")
+                            << "Coroutine " << name << " ran for "
+                            << elapsed << " seconds" << LL_ENDL;
+                    });
+            }
+        }
+    }
 
     boost::fibers::context* next;
 
@@ -96,17 +135,9 @@ boost::fibers::context* scheduler::pick_next() noexcept
         // passage could be skipped.
 
         // Record this event for logging, but push it off to a thread pool to
-        // perform that work. Presumably std::weak_ptr::lock() is cheaper than
-        // WorkQueue::getInstance().
-        LL::WorkQueue::ptr_t queue{ mQueue.lock() };
-        // We probably started before the relevant WorkQueue was created.
-        if (! queue)
-        {
-            // Try again to locate the specified WorkQueue.
-            queue = LL::WorkQueue::getInstance(qname);
-            mQueue = queue;
-        }
-        // Both the lock() call and the getInstance() call might have failed.
+        // perform that work.
+        LL::WorkQueue::ptr_t queue{ getWorkQueue() };
+        // The work queue we're looking for might not exist right now.
         if (queue)
         {
             // Bind values. Do NOT bind 'this' to avoid cross-thread access!
@@ -116,7 +147,6 @@ boost::fibers::context* scheduler::pick_next() noexcept
             // so we have no access.
             queue->post(
                 [switches=mSwitches, start=mStart, elapsed, now]
-                ()
                 {
                     U32 runtime(U32(now) - U32(start));
                     U32 minutes(runtime / 60u);
@@ -150,12 +180,29 @@ boost::fibers::context* scheduler::pick_next() noexcept
     {
         // we're about to resume the main fiber: it's no longer "ready"
         mMainCtx = nullptr;
-        // instead, it's "running"
-        mMainRunning = true;
     }
+    mPrevCtx = next;
+    // remember when we resumed this fiber so our next call can measure how
+    // long the previous resumption was
+    mResumeTime = LLDate::now().secondsSinceEpoch();
     return next;
 }
 
+LL::WorkQueue::ptr_t scheduler::getWorkQueue()
+{
+    // Cache a weak_ptr to our target work queue, presuming that
+    // std::weak_ptr::lock() is cheaper than WorkQueue::getInstance().
+    LL::WorkQueue::ptr_t queue{ mQueue.lock() };
+    // We probably started before the relevant WorkQueue was created.
+    if (! queue)
+    {
+        // Try again to locate the specified WorkQueue.
+        queue = LL::WorkQueue::getInstance(qname);
+        mQueue = queue;
+    }
+    return queue;
+}
+
 void scheduler::use()
 {
     boost::fibers::use_scheduling_algorithm<scheduler>();
diff --git a/indra/llcommon/coro_scheduler.h b/indra/llcommon/coro_scheduler.h
index eee2d746b5..7af90685dc 100644
--- a/indra/llcommon/coro_scheduler.h
+++ b/indra/llcommon/coro_scheduler.h
@@ -47,17 +47,20 @@ public:
     static void use();
 
 private:
-    // This is the fiber::id of the main fiber. We use this to discover
-    // whether the fiber passed to awakened() is in fact the main fiber.
+    LL::WorkQueue::ptr_t getWorkQueue();
+
+    // This is the fiber::id of the main fiber.
     boost::fibers::fiber::id mMainID;
-    // This context* is nullptr until awakened() notices that the main fiber
-    // has become ready, at which point it contains the main fiber's context*.
+    // This context* is nullptr while the main fiber is running or suspended,
+    // but is set to the main fiber's context each time the main fiber is ready.
     boost::fibers::context* mMainCtx{};
-    // Set when pick_next() returns the main fiber.
-    bool mMainRunning{ false };
+    // Remember the context returned by the previous pick_next() call.
+    boost::fibers::context* mPrevCtx{};
     // If it's been at least this long since the last time the main fiber got
     // control, jump it to the head of the queue.
     F64 mTimeslice{ DEFAULT_TIMESLICE };
+    // Time when we resumed the most recently running fiber
+    F64 mResumeTime{ 0 };
     // Timestamp as of the last time we suspended the main fiber.
     F64 mMainLast{ 0 };
     // Timestamp of start time
diff --git a/indra/llcommon/fsyspath.h b/indra/llcommon/fsyspath.h
index 1b4aec09b4..f66970ed8f 100644
--- a/indra/llcommon/fsyspath.h
+++ b/indra/llcommon/fsyspath.h
@@ -12,7 +12,10 @@
 #if ! defined(LL_FSYSPATH_H)
 #define LL_FSYSPATH_H
 
+#include <boost/iterator/transform_iterator.hpp>
 #include <filesystem>
+#include <string>
+#include <string_view>
 
 // While std::filesystem::path can be directly constructed from std::string on
 // both Posix and Windows, that's not what we want on Windows. Per
@@ -33,42 +36,55 @@
 // char"), the "native narrow encoding" isn't UTF-8, so file paths containing
 // non-ASCII characters get mangled.
 //
-// Once we're building with C++20, we could pass a UTF-8 std::string through a
-// vector<char8_t> to engage std::filesystem::path's own UTF-8 conversion. But
-// sigh, as of 2024-04-03 we're not yet there.
-//
-// Anyway, encapsulating the important UTF-8 conversions in our own subclass
-// allows us to migrate forward to C++20 conventions without changing
-// referencing code.
+// Encapsulating the important UTF-8 conversions in our own subclass allows us
+// to migrate forward to C++20 conventions without changing referencing code.
 
 class fsyspath: public std::filesystem::path
 {
     using super = std::filesystem::path;
 
+    // In C++20 (__cpp_lib_char8_t), std::filesystem::u8path() is deprecated.
+    // std::filesystem::path(iter, iter) performs UTF-8 conversions when the
+    // value_type of the iterators is char8_t. While we could copy into a
+    // temporary std::u8string and from there into std::filesystem::path, to
+    // minimize string copying we'll define a transform_iterator that accepts
+    // a std::string_view::iterator and dereferences to char8_t.
+    struct u8ify
+    {
+        char8_t operator()(char c) const { return char8_t(c); }
+    };
+    using u8iter = boost::transform_iterator<u8ify, std::string_view::iterator>;
+
 public:
     // default
     fsyspath() {}
-    // construct from UTF-8 encoded std::string
-    fsyspath(const std::string& path): super(std::filesystem::u8path(path)) {}
-    // construct from UTF-8 encoded const char*
-    fsyspath(const char* path): super(std::filesystem::u8path(path)) {}
+    // construct from UTF-8 encoded string
+    fsyspath(const std::string& path): fsyspath(std::string_view(path)) {}
+    fsyspath(const char* path):        fsyspath(std::string_view(path)) {}
+    fsyspath(std::string_view path):
+        super(u8iter(path.begin(), u8ify()), u8iter(path.end(), u8ify()))
+    {}
     // construct from existing path
     fsyspath(const super& path): super(path) {}
 
-    fsyspath& operator=(const super& p) { super::operator=(p); return *this; }
-    fsyspath& operator=(const std::string& p)
-    {
-        super::operator=(std::filesystem::u8path(p));
-        return *this;
-    }
-    fsyspath& operator=(const char* p)
+    fsyspath& operator=(const super& p)       { super::operator=(p); return *this; }
+    fsyspath& operator=(const std::string& p) { return (*this) = std::string_view(p); }
+    fsyspath& operator=(const char* p)        { return (*this) = std::string_view(p); }
+    fsyspath& operator=(std::string_view p)
     {
-        super::operator=(std::filesystem::u8path(p));
+        assign(u8iter(p.begin(), u8ify()), u8iter(p.end(), u8ify()));
         return *this;
     }
 
     // shadow base-class string() method with UTF-8 aware method
-    std::string string() const { return super::u8string(); }
+    std::string string() const
+    {
+        // Short of forbidden type punning, I see no way to avoid copying this
+        // std::u8string to a std::string.
+        auto u8str{ super::u8string() };
+        // from https://github.com/tahonermann/char8_t-remediation/blob/master/char8_t-remediation.h#L180-L182
+        return { u8str.begin(), u8str.end() };
+    }
     // On Posix systems, where value_type is already char, this operator
     // std::string() method shadows the base class operator string_type()
     // method. But on Windows, where value_type is wchar_t, the base class
diff --git a/indra/llcommon/llcoros.cpp b/indra/llcommon/llcoros.cpp
index 1ae5c87a00..5a3cbd2ef1 100644
--- a/indra/llcommon/llcoros.cpp
+++ b/indra/llcommon/llcoros.cpp
@@ -57,16 +57,19 @@
 #include "llsdutil.h"
 #include "lltimer.h"
 #include "stringize.h"
+#include "scope_exit.h"
 
 #if LL_WINDOWS
 #include <excpt.h>
 #endif
 
+thread_local std::unordered_map<std::string, int> LLCoros::mPrefixMap;
+thread_local std::unordered_map<std::string, LLCoros::id> LLCoros::mNameMap;
+
 // static
 bool LLCoros::on_main_coro()
 {
-    return (!LLCoros::instanceExists() ||
-            LLCoros::getName().empty());
+    return (!instanceExists() || get_CoroData().isMain);
 }
 
 // static
@@ -76,11 +79,11 @@ bool LLCoros::on_main_thread_main_coro()
 }
 
 // static
-LLCoros::CoroData& LLCoros::get_CoroData(const std::string&)
+LLCoros::CoroData& LLCoros::get_CoroData()
 {
     CoroData* current{ nullptr };
     // be careful about attempted accesses in the final throes of app shutdown
-    if (! wasDeleted())
+    if (instanceExists())
     {
         current = instance().mCurrent.get();
     }
@@ -89,16 +92,26 @@ LLCoros::CoroData& LLCoros::get_CoroData(const std::string&)
     // canonical values.
     if (! current)
     {
-        static std::atomic<int> which_thread(0);
-        // Use alternate CoroData constructor.
-        static thread_local CoroData sMain(which_thread++);
         // We need not reset() the local_ptr to this instance; we'll simply
         // find it again every time we discover that current is null.
-        current = &sMain;
+        current = &main_CoroData();
     }
     return *current;
 }
 
+LLCoros::CoroData& LLCoros::get_CoroData(id id)
+{
+    auto found = CoroData::getInstance(id);
+    return found? *found : main_CoroData();
+}
+
+LLCoros::CoroData& LLCoros::main_CoroData()
+{
+    // tell CoroData we're "main"
+    static thread_local CoroData sMain("");
+    return sMain;
+}
+
 //static
 LLCoros::coro::id LLCoros::get_self()
 {
@@ -108,28 +121,28 @@ LLCoros::coro::id LLCoros::get_self()
 //static
 void LLCoros::set_consuming(bool consuming)
 {
-    auto& data(get_CoroData("set_consuming()"));
+    auto& data(get_CoroData());
     // DO NOT call this on the main() coroutine.
-    llassert_always(! data.mName.empty());
+    llassert_always(! data.isMain);
     data.mConsuming = consuming;
 }
 
 //static
 bool LLCoros::get_consuming()
 {
-    return get_CoroData("get_consuming()").mConsuming;
+    return get_CoroData().mConsuming;
 }
 
 // static
 void LLCoros::setStatus(const std::string& status)
 {
-    get_CoroData("setStatus()").mStatus = status;
+    get_CoroData().mStatus = status;
 }
 
 // static
 std::string LLCoros::getStatus()
 {
-    return get_CoroData("getStatus()").mStatus;
+    return get_CoroData().mStatus;
 }
 
 LLCoros::LLCoros():
@@ -186,9 +199,8 @@ void LLCoros::cleanupSingleton()
 
 std::string LLCoros::generateDistinctName(const std::string& prefix) const
 {
-    static int unique = 0;
-
-    // Allowing empty name would make getName()'s not-found return ambiguous.
+    // Empty name would trigger CoroData's constructor's special case for the
+    // main coroutine.
     if (prefix.empty())
     {
         LL_ERRS("LLCoros") << "LLCoros::launch(): pass non-empty name string" << LL_ENDL;
@@ -196,9 +208,11 @@ std::string LLCoros::generateDistinctName(const std::string& prefix) const
 
     // If the specified name isn't already in the map, just use that.
     std::string name(prefix);
+    // maintain a distinct int suffix for each prefix
+    int& unique = mPrefixMap[prefix];
 
-    // Until we find an unused name, append a numeric suffix for uniqueness.
-    while (CoroData::getInstance(name))
+    // Until we find an unused name, append int suffix for uniqueness.
+    while (mNameMap.find(name) != mNameMap.end())
     {
         name = stringize(prefix, unique++);
     }
@@ -207,9 +221,16 @@ std::string LLCoros::generateDistinctName(const std::string& prefix) const
 
 bool LLCoros::killreq(const std::string& name)
 {
-    auto found = CoroData::getInstance(name);
+    auto foundName = mNameMap.find(name);
+    if (foundName == mNameMap.end())
+    {
+        // couldn't find that name in map
+        return false;
+    }
+    auto found = CoroData::getInstance(foundName->second);
     if (! found)
     {
+        // found name, but CoroData with that ID key no longer exists
         return false;
     }
     // Next time the subject coroutine calls checkStop(), make it terminate.
@@ -224,14 +245,13 @@ bool LLCoros::killreq(const std::string& name)
 //static
 std::string LLCoros::getName()
 {
-    return get_CoroData("getName()").mName;
+    return get_CoroData().getName();
 }
 
-//static
-std::string LLCoros::logname()
+// static
+std::string LLCoros::getName(id id)
 {
-    auto& data(get_CoroData("logname()"));
-    return data.mName.empty()? data.getKey() : data.mName;
+    return get_CoroData(id).getName();
 }
 
 void LLCoros::saveException(const std::string& name, std::exception_ptr exc)
@@ -264,7 +284,7 @@ void LLCoros::printActiveCoroutines(const std::string& when)
     {
         LL_INFOS("LLCoros") << "-------------- List of active coroutines ------------";
         F64 time = LLTimer::getTotalSeconds();
-        for (auto& cd : CoroData::instance_snapshot())
+        for (const auto& cd : CoroData::instance_snapshot())
         {
             F64 life_time = time - cd.mCreationTime;
             LL_CONT << LL_NEWLINE
@@ -323,6 +343,33 @@ void LLCoros::toplevel(std::string name, callable_t callable)
     // run the code the caller actually wants in the coroutine
     try
     {
+        LL::scope_exit report{
+            [&corodata]
+            {
+                bool allzero = true;
+                for (const auto& [threshold, occurs] : corodata.mHistogram)
+                {
+                    if (occurs)
+                    {
+                        allzero = false;
+                        break;
+                    }
+                }
+                if (! allzero)
+                {
+                    LL_WARNS("LLCoros") << "coroutine " << corodata.mName;
+                    const char* sep = " exceeded ";
+                    for (const auto& [threshold, occurs] : corodata.mHistogram)
+                    {
+                        if (occurs)
+                        {
+                            LL_CONT << sep << threshold << " " << occurs << " times";
+                            sep = ", ";
+                        }
+                    }
+                    LL_ENDL;
+                }
+            }};
         LL::seh::catcher(callable);
     }
     catch (const Stop& exc)
@@ -364,8 +411,8 @@ void LLCoros::checkStop(callable_t cleanup)
 
     // do this AFTER the check above, because get_CoroData() depends on the
     // local_ptr in our instance().
-    auto& data(get_CoroData("checkStop()"));
-    if (data.mName.empty())
+    auto& data(get_CoroData());
+    if (data.isMain)
     {
         // Our Stop exception and its subclasses are intended to stop loitering
         // coroutines. Don't throw it from the main coroutine.
@@ -385,7 +432,7 @@ void LLCoros::checkStop(callable_t cleanup)
     {
         // Someone wants to kill this coroutine
         cleanup();
-        LLTHROW(Killed(stringize("coroutine ", data.mName, " killed by ", data.mKilledBy)));
+        LLTHROW(Killed(stringize("coroutine ", data.getName(), " killed by ", data.mKilledBy)));
     }
 }
 
@@ -445,20 +492,51 @@ LLBoundListener LLCoros::getStopListener(const std::string& caller,
 }
 
 LLCoros::CoroData::CoroData(const std::string& name):
-    LLInstanceTracker<CoroData, std::string>(name),
+    super(boost::this_fiber::get_id()),
     mName(name),
-    mCreationTime(LLTimer::getTotalSeconds())
+    mCreationTime(LLTimer::getTotalSeconds()),
+    // Preset threshold times in mHistogram
+    mHistogram{
+        {0.004, 0},
+        {0.040, 0},
+        {0.400, 0},
+        {1.000, 0}
+    }
 {
+    // we expect the empty string for the main coroutine
+    if (name.empty())
+    {
+        isMain = true;
+        if (on_main_thread())
+        {
+            // main coroutine on main thread
+            mName = "main";
+        }
+        else
+        {
+            // main coroutine on some other thread
+            static std::atomic<int> main_no{ 0 };
+            mName = stringize("main", ++main_no);
+        }
+    }
+    // maintain LLCoros::mNameMap
+    LLCoros::mNameMap.emplace(mName, getKey());
+}
+
+LLCoros::CoroData::~CoroData()
+{
+    // Don't try to erase the static main CoroData from our static
+    // thread_local mNameMap; that could run into destruction order problems.
+    if (! isMain)
+    {
+        LLCoros::mNameMap.erase(mName);
+    }
 }
 
-LLCoros::CoroData::CoroData(int n):
-    // This constructor is used for the thread_local instance belonging to the
-    // default coroutine on each thread. We must give each one a different
-    // LLInstanceTracker key because LLInstanceTracker's map spans all
-    // threads, but we want the default coroutine on each thread to have the
-    // empty string as its visible name because some consumers test for that.
-    LLInstanceTracker<CoroData, std::string>("main" + stringize(n)),
-    mName(),
-    mCreationTime(LLTimer::getTotalSeconds())
+std::string LLCoros::CoroData::getName() const
 {
+    if (mStatus.empty())
+        return mName;
+    else
+        return stringize(mName, " (", mStatus, ")");
 }
diff --git a/indra/llcommon/llcoros.h b/indra/llcommon/llcoros.h
index 0291d7f1d9..1edcb7e387 100644
--- a/indra/llcommon/llcoros.h
+++ b/indra/llcommon/llcoros.h
@@ -37,41 +37,38 @@
 #include <boost/fiber/fss.hpp>
 #include <exception>
 #include <functional>
+#include <map>
 #include <queue>
 #include <string>
+#include <unordered_map>
+
+namespace llcoro
+{
+class scheduler;
+}
 
 /**
- * Registry of named Boost.Coroutine instances
- *
- * The Boost.Coroutine library supports the general case of a coroutine
- * accepting arbitrary parameters and yielding multiple (sets of) results. For
- * such use cases, it's natural for the invoking code to retain the coroutine
- * instance: the consumer repeatedly calls into the coroutine, perhaps passing
- * new parameter values, prompting it to yield its next result.
- *
- * Our typical coroutine usage is different, though. For us, coroutines
- * provide an alternative to the @c Responder pattern. Our typical coroutine
- * has @c void return, invoked in fire-and-forget mode: the handler for some
- * user gesture launches the coroutine and promptly returns to the main loop.
- * The coroutine initiates some action that will take multiple frames (e.g. a
- * capability request), waits for its result, processes it and silently steals
- * away.
+ * Registry of named Boost.Fiber instances
  *
- * This usage poses two (related) problems:
+ * When the viewer first introduced the semi-independent execution agents now
+ * called fibers, the term "fiber" had not yet become current, and the only
+ * available libraries used the term "coroutine" instead. Within the viewer we
+ * continue to use the term "coroutines," though at present they are actually
+ * boost::fibers::fiber instances.
  *
- * # Who should own the coroutine instance? If it's simply local to the
- *   handler code that launches it, return from the handler will destroy the
- *   coroutine object, terminating the coroutine.
- * # Once the coroutine terminates, in whatever way, who's responsible for
- *   cleaning up the coroutine object?
+ * Coroutines provide an alternative to the @c Responder pattern. Our typical
+ * coroutine has @c void return, invoked in fire-and-forget mode: the handler
+ * for some user gesture launches the coroutine and promptly returns to the
+ * main loop. The coroutine initiates some action that will take multiple
+ * frames (e.g. a capability request), waits for its result, processes it and
+ * silently steals away.
  *
  * LLCoros is a Singleton collection of currently-active coroutine instances.
  * Each has a name. You ask LLCoros to launch a new coroutine with a suggested
  * name prefix; from your prefix it generates a distinct name, registers the
  * new coroutine and returns the actual name.
  *
- * The name
- * can provide diagnostic info: we can look up the name of the
+ * The name can provide diagnostic info: we can look up the name of the
  * currently-running coroutine.
  */
 class LL_COMMON_API LLCoros: public LLSingleton<LLCoros>
@@ -91,12 +88,8 @@ public:
     // llassert(LLCoros::on_main_thread_main_coro())
     static bool on_main_thread_main_coro();
 
-    /// The viewer's use of the term "coroutine" became deeply embedded before
-    /// the industry term "fiber" emerged to distinguish userland threads from
-    /// simpler, more transient kinds of coroutines. Semantically they've
-    /// always been fibers. But at this point in history, we're pretty much
-    /// stuck with the term "coroutine."
     typedef boost::fibers::fiber coro;
+    typedef coro::id id;
     /// Canonical callable type
     typedef std::function<void()> callable_t;
 
@@ -150,13 +143,16 @@ public:
 
     /**
      * From within a coroutine, look up the (tweaked) name string by which
-     * this coroutine is registered. Returns the empty string if not found
-     * (e.g. if the coroutine was launched by hand rather than using
-     * LLCoros::launch()).
+     * this coroutine is registered.
      */
     static std::string getName();
 
     /**
+     * Given an id, return the name of that coroutine.
+     */
+    static std::string getName(id);
+
+    /**
      * rethrow() is called by the thread's main fiber to propagate an
      * exception from any coroutine into the main fiber, where it can engage
      * the normal unhandled-exception machinery, up to and including crash
@@ -170,13 +166,6 @@ public:
     void rethrow();
 
     /**
-     * This variation returns a name suitable for log messages: the explicit
-     * name for an explicitly-launched coroutine, or "mainN" for the default
-     * coroutine on a thread.
-     */
-    static std::string logname();
-
-    /**
      * For delayed initialization. To be clear, this will only affect
      * coroutines launched @em after this point. The underlying facility
      * provides no way to alter the stack size of any running coroutine.
@@ -187,7 +176,7 @@ public:
     void printActiveCoroutines(const std::string& when=std::string());
 
     /// get the current coro::id for those who really really care
-    static coro::id get_self();
+    static id get_self();
 
     /**
      * Most coroutines, most of the time, don't "consume" the events for which
@@ -236,6 +225,7 @@ public:
             setStatus(status);
         }
         TempStatus(const TempStatus&) = delete;
+        TempStatus& operator=(const TempStatus&) = delete;
         ~TempStatus()
         {
             setStatus(mOldStatus);
@@ -331,10 +321,14 @@ public:
     using local_ptr = boost::fibers::fiber_specific_ptr<T>;
 
 private:
+    friend class llcoro::scheduler;
+
     std::string generateDistinctName(const std::string& prefix) const;
     void toplevel(std::string name, callable_t callable);
     struct CoroData;
-    static CoroData& get_CoroData(const std::string& caller);
+    static CoroData& get_CoroData();
+    static CoroData& get_CoroData(id);
+    static CoroData& main_CoroData();
     void saveException(const std::string& name, std::exception_ptr exc);
 
     LLTempBoundListener mConn;
@@ -355,13 +349,18 @@ private:
     S32 mStackSize;
 
     // coroutine-local storage, as it were: one per coro we track
-    struct CoroData: public LLInstanceTracker<CoroData, std::string>
+    struct CoroData: public LLInstanceTracker<CoroData, id>
     {
+        using super = LLInstanceTracker<CoroData, id>;
+
         CoroData(const std::string& name);
-        CoroData(int n);
+        ~CoroData();
 
+        std::string getName() const;
+
+        bool isMain{ false };
         // tweaked name of the current coroutine
-        const std::string mName;
+        std::string mName;
         // set_consuming() state -- don't consume events unless specifically directed
         bool mConsuming{ false };
         // killed by which coroutine
@@ -369,20 +368,24 @@ private:
         // setStatus() state
         std::string mStatus;
         F64 mCreationTime; // since epoch
+        // Histogram of how many times this coroutine's timeslice exceeds
+        // certain thresholds. mHistogram is pre-populated with those
+        // thresholds as keys. If k0 is one threshold key and k1 is the next,
+        // mHistogram[k0] is the number of times a coroutine timeslice tn ran
+        // (k0 <= tn < k1). A timeslice less than mHistogram.begin()->first is
+        // fine; we don't need to record those.
+        std::map<F64, U32> mHistogram;
     };
 
     // Identify the current coroutine's CoroData. This local_ptr isn't static
     // because it's a member of an LLSingleton, and we rely on it being
     // cleaned up in proper dependency order.
     local_ptr<CoroData> mCurrent;
-};
 
-namespace llcoro
-{
-
-inline
-std::string logname() { return LLCoros::logname(); }
-
-} // llcoro
+    // ensure name uniqueness
+    static thread_local std::unordered_map<std::string, int> mPrefixMap;
+    // lookup by name
+    static thread_local std::unordered_map<std::string, id> mNameMap;
+};
 
 #endif /* ! defined(LL_LLCOROS_H) */
diff --git a/indra/llcommon/llerror.h b/indra/llcommon/llerror.h
index b17b9ff21e..b6d560a121 100644
--- a/indra/llcommon/llerror.h
+++ b/indra/llcommon/llerror.h
@@ -239,17 +239,12 @@ namespace LLError
 
         ~CallSite();
 
-#ifdef LL_LIBRARY_INCLUDE
-        bool shouldLog();
-#else // LL_LIBRARY_INCLUDE
         bool shouldLog()
         {
             return mCached
                     ? mShouldLog
                     : Log::shouldLog(*this);
         }
-            // this member function needs to be in-line for efficiency
-#endif // LL_LIBRARY_INCLUDE
 
         void invalidate();
 
diff --git a/indra/llcommon/llkeybind.cpp b/indra/llcommon/llkeybind.cpp
index 83c53d220d..73a207504e 100644
--- a/indra/llcommon/llkeybind.cpp
+++ b/indra/llcommon/llkeybind.cpp
@@ -125,20 +125,16 @@ LLKeyData& LLKeyData::operator=(const LLKeyData& rhs)
 
 bool LLKeyData::operator==(const LLKeyData& rhs) const
 {
-    if (mMouse != rhs.mMouse) return false;
-    if (mKey != rhs.mKey) return false;
-    if (mMask != rhs.mMask) return false;
-    if (mIgnoreMasks != rhs.mIgnoreMasks) return false;
-    return true;
+    return
+        (mMouse       == rhs.mMouse) &&
+        (mKey         == rhs.mKey) &&
+        (mMask        == rhs.mMask) &&
+        (mIgnoreMasks == rhs.mIgnoreMasks);
 }
 
 bool LLKeyData::operator!=(const LLKeyData& rhs) const
 {
-    if (mMouse != rhs.mMouse) return true;
-    if (mKey != rhs.mKey) return true;
-    if (mMask != rhs.mMask) return true;
-    if (mIgnoreMasks != rhs.mIgnoreMasks) return true;
-    return false;
+    return ! (*this == rhs);
 }
 
 bool LLKeyData::canHandle(const LLKeyData& data) const
diff --git a/indra/llcommon/llpointer.cpp b/indra/llcommon/llpointer.cpp
new file mode 100755
index 0000000000..adea447caa
--- /dev/null
+++ b/indra/llcommon/llpointer.cpp
@@ -0,0 +1,26 @@
+/**
+ * @file   llpointer.cpp
+ * @author Nat Goodspeed
+ * @date   2024-09-26
+ * @brief  Implementation for llpointer.
+ *
+ * $LicenseInfo:firstyear=2024&license=viewerlgpl$
+ * Copyright (c) 2024, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+// Precompiled header
+#include "linden_common.h"
+// associated header
+#include "llpointer.h"
+// STL headers
+// std headers
+// external library headers
+// other Linden headers
+#include "llerror.h"
+
+void LLPointerBase::wild_dtor(std::string_view msg)
+{
+//  LL_WARNS() << msg << LL_ENDL;
+    llassert_msg(false, msg);
+}
diff --git a/indra/llcommon/llpointer.h b/indra/llcommon/llpointer.h
index 048547e4cc..b53cfcdd1a 100644
--- a/indra/llcommon/llpointer.h
+++ b/indra/llcommon/llpointer.h
@@ -26,8 +26,9 @@
 #ifndef LLPOINTER_H
 #define LLPOINTER_H
 
-#include "llerror.h"    // *TODO: consider eliminating this
-#include "llmutex.h"
+#include <boost/functional/hash.hpp>
+#include <string_view>
+#include <utility>                  // std::swap()
 
 //----------------------------------------------------------------------------
 // RefCount objects should generally only be accessed by way of LLPointer<>'s
@@ -42,8 +43,18 @@
 
 //----------------------------------------------------------------------------
 
+class LLPointerBase
+{
+protected:
+    // alert the coder that a referenced type's destructor did something very
+    // strange -- this is in a non-template base class so we can hide the
+    // implementation in llpointer.cpp
+    static void wild_dtor(std::string_view msg);
+};
+
 // Note: relies on Type having ref() and unref() methods
-template <class Type> class LLPointer
+template <class Type>
+class LLPointer: public LLPointerBase
 {
 public:
     template<typename Subclass>
@@ -60,6 +71,13 @@ public:
         ref();
     }
 
+    // Even though the template constructors below accepting
+    // (const LLPointer<Subclass>&) and (LLPointer<Subclass>&&) appear to
+    // subsume these specific (const LLPointer<Type>&) and (LLPointer<Type>&&)
+    // constructors, the compiler recognizes these as The Copy Constructor and
+    // The Move Constructor, respectively. In other words, even in the
+    // presence of the LLPointer<Subclass> constructors, we still must specify
+    // the LLPointer<Type> constructors.
     LLPointer(const LLPointer<Type>& ptr) :
         mPointer(ptr.mPointer)
     {
@@ -98,39 +116,52 @@ public:
     const Type& operator*() const               { return *mPointer; }
     Type&   operator*()                         { return *mPointer; }
 
-    operator BOOL() const                       { return (mPointer != nullptr); }
     operator bool() const                       { return (mPointer != nullptr); }
     bool operator!() const                      { return (mPointer == nullptr); }
     bool isNull() const                         { return (mPointer == nullptr); }
     bool notNull() const                        { return (mPointer != nullptr); }
 
     operator Type*() const                      { return mPointer; }
-    bool operator !=(Type* ptr) const           { return (mPointer != ptr); }
-    bool operator ==(Type* ptr) const           { return (mPointer == ptr); }
-    bool operator ==(const LLPointer<Type>& ptr) const { return (mPointer == ptr.mPointer); }
-    bool operator < (const LLPointer<Type>& ptr) const { return (mPointer < ptr.mPointer); }
-    bool operator > (const LLPointer<Type>& ptr) const { return (mPointer > ptr.mPointer); }
+    template <typename Type1>
+    bool operator !=(Type1* ptr) const          { return (mPointer != ptr); }
+    template <typename Type1>
+    bool operator ==(Type1* ptr) const          { return (mPointer == ptr); }
+    template <typename Type1>
+    bool operator !=(const LLPointer<Type1>& ptr) const { return (mPointer != ptr.mPointer); }
+    template <typename Type1>
+    bool operator ==(const LLPointer<Type1>& ptr) const { return (mPointer == ptr.mPointer); }
+    bool operator < (const LLPointer<Type>& ptr)  const { return (mPointer < ptr.mPointer); }
+    bool operator > (const LLPointer<Type>& ptr)  const { return (mPointer > ptr.mPointer); }
 
     LLPointer<Type>& operator =(Type* ptr)
     {
-        assign(ptr);
+        // copy-and-swap idiom, see http://gotw.ca/gotw/059.htm
+        LLPointer temp(ptr);
+        using std::swap;            // per Swappable convention
+        swap(*this, temp);
         return *this;
     }
 
+    // Even though the template assignment operators below accepting
+    // (const LLPointer<Subclass>&) and (LLPointer<Subclass>&&) appear to
+    // subsume these specific (const LLPointer<Type>&) and (LLPointer<Type>&&)
+    // assignment operators, the compiler recognizes these as Copy Assignment
+    // and Move Assignment, respectively. In other words, even in the presence
+    // of the LLPointer<Subclass> assignment operators, we still must specify
+    // the LLPointer<Type> operators.
     LLPointer<Type>& operator =(const LLPointer<Type>& ptr)
     {
-        assign(ptr);
+        LLPointer temp(ptr);
+        using std::swap;            // per Swappable convention
+        swap(*this, temp);
         return *this;
     }
 
     LLPointer<Type>& operator =(LLPointer<Type>&& ptr)
     {
-        if (mPointer != ptr.mPointer)
-        {
-            unref();
-            mPointer = ptr.mPointer;
-            ptr.mPointer = nullptr;
-        }
+        LLPointer temp(std::move(ptr));
+        using std::swap;            // per Swappable convention
+        swap(*this, temp);
         return *this;
     }
 
@@ -138,210 +169,35 @@ public:
     template<typename Subclass>
     LLPointer<Type>& operator =(const LLPointer<Subclass>& ptr)
     {
-        assign(ptr.get());
+        LLPointer temp(ptr);
+        using std::swap;            // per Swappable convention
+        swap(*this, temp);
         return *this;
     }
 
     template<typename Subclass>
     LLPointer<Type>& operator =(LLPointer<Subclass>&& ptr)
     {
-        if (mPointer != ptr.mPointer)
-        {
-            unref();
-            mPointer = ptr.mPointer;
-            ptr.mPointer = nullptr;
-        }
+        LLPointer temp(std::move(ptr));
+        using std::swap;            // per Swappable convention
+        swap(*this, temp);
         return *this;
     }
 
     // Just exchange the pointers, which will not change the reference counts.
     static void swap(LLPointer<Type>& a, LLPointer<Type>& b)
     {
-        Type* temp = a.mPointer;
-        a.mPointer = b.mPointer;
-        b.mPointer = temp;
-    }
-
-protected:
-#ifdef LL_LIBRARY_INCLUDE
-    void ref();
-    void unref();
-#else
-    void ref()
-    {
-        if (mPointer)
-        {
-            mPointer->ref();
-        }
-    }
-
-    void unref()
-    {
-        if (mPointer)
-        {
-            Type *temp = mPointer;
-            mPointer = nullptr;
-            temp->unref();
-            if (mPointer != nullptr)
-            {
-                LL_WARNS() << "Unreference did assignment to non-NULL because of destructor" << LL_ENDL;
-                unref();
-            }
-        }
-    }
-#endif // LL_LIBRARY_INCLUDE
-
-    void assign(const LLPointer<Type>& ptr)
-    {
-        if (mPointer != ptr.mPointer)
-        {
-            unref();
-            mPointer = ptr.mPointer;
-            ref();
-        }
-    }
-
-protected:
-    Type*   mPointer;
-};
-
-template <class Type> class LLConstPointer
-{
-    template<typename Subclass>
-    friend class LLConstPointer;
-public:
-    LLConstPointer() :
-        mPointer(nullptr)
-    {
-    }
-
-    LLConstPointer(const Type* ptr) :
-        mPointer(ptr)
-    {
-        ref();
-    }
-
-    LLConstPointer(const LLConstPointer<Type>& ptr) :
-        mPointer(ptr.mPointer)
-    {
-        ref();
-    }
-
-    LLConstPointer(LLConstPointer<Type>&& ptr) noexcept
-    {
-        mPointer = ptr.mPointer;
-        ptr.mPointer = nullptr;
-    }
-
-    // support conversion up the type hierarchy.  See Item 45 in Effective C++, 3rd Ed.
-    template<typename Subclass>
-    LLConstPointer(const LLConstPointer<Subclass>& ptr) :
-        mPointer(ptr.get())
-    {
-        ref();
-    }
-
-    template<typename Subclass>
-    LLConstPointer(LLConstPointer<Subclass>&& ptr) noexcept :
-        mPointer(ptr.get())
-    {
-        ptr.mPointer = nullptr;
-    }
-
-    ~LLConstPointer()
-    {
-        unref();
-    }
-
-    const Type* get() const                     { return mPointer; }
-    const Type* operator->() const              { return mPointer; }
-    const Type& operator*() const               { return *mPointer; }
-
-    operator BOOL() const                       { return (mPointer != nullptr); }
-    operator bool() const                       { return (mPointer != nullptr); }
-    bool operator!() const                      { return (mPointer == nullptr); }
-    bool isNull() const                         { return (mPointer == nullptr); }
-    bool notNull() const                        { return (mPointer != nullptr); }
-
-    operator const Type*() const                { return mPointer; }
-    bool operator !=(const Type* ptr) const     { return (mPointer != ptr); }
-    bool operator ==(const Type* ptr) const     { return (mPointer == ptr); }
-    bool operator ==(const LLConstPointer<Type>& ptr) const { return (mPointer == ptr.mPointer); }
-    bool operator < (const LLConstPointer<Type>& ptr) const { return (mPointer < ptr.mPointer); }
-    bool operator > (const LLConstPointer<Type>& ptr) const { return (mPointer > ptr.mPointer); }
-
-    LLConstPointer<Type>& operator =(const Type* ptr)
-    {
-        if( mPointer != ptr )
-        {
-            unref();
-            mPointer = ptr;
-            ref();
-        }
-
-        return *this;
-    }
-
-    LLConstPointer<Type>& operator =(const LLConstPointer<Type>& ptr)
-    {
-        if( mPointer != ptr.mPointer )
-        {
-            unref();
-            mPointer = ptr.mPointer;
-            ref();
-        }
-        return *this;
-    }
-
-    LLConstPointer<Type>& operator =(LLConstPointer<Type>&& ptr)
-    {
-        if (mPointer != ptr.mPointer)
-        {
-            unref();
-            mPointer = ptr.mPointer;
-            ptr.mPointer = nullptr;
-        }
-        return *this;
-    }
-
-    // support assignment up the type hierarchy. See Item 45 in Effective C++, 3rd Ed.
-    template<typename Subclass>
-    LLConstPointer<Type>& operator =(const LLConstPointer<Subclass>& ptr)
-    {
-        if( mPointer != ptr.get() )
-        {
-            unref();
-            mPointer = ptr.get();
-            ref();
-        }
-        return *this;
-    }
-
-    template<typename Subclass>
-    LLConstPointer<Type>& operator =(LLConstPointer<Subclass>&& ptr)
-    {
-        if (mPointer != ptr.mPointer)
-        {
-            unref();
-            mPointer = ptr.mPointer;
-            ptr.mPointer = nullptr;
-        }
-        return *this;
+        using std::swap;            // per Swappable convention
+        swap(a.mPointer, b.mPointer);
     }
 
-    // Just exchange the pointers, which will not change the reference counts.
-    static void swap(LLConstPointer<Type>& a, LLConstPointer<Type>& b)
+    // Put swap() overload in the global namespace, per Swappable convention
+    friend void swap(LLPointer<Type>& a, LLPointer<Type>& b)
     {
-        const Type* temp = a.mPointer;
-        a.mPointer = b.mPointer;
-        b.mPointer = temp;
+        LLPointer<Type>::swap(a, b);
     }
 
 protected:
-#ifdef LL_LIBRARY_INCLUDE
-    void ref();
-    void unref();
-#else // LL_LIBRARY_INCLUDE
     void ref()
     {
         if (mPointer)
@@ -354,22 +210,24 @@ protected:
     {
         if (mPointer)
         {
-            const Type *temp = mPointer;
+            Type *temp = mPointer;
             mPointer = nullptr;
             temp->unref();
             if (mPointer != nullptr)
             {
-                LL_WARNS() << "Unreference did assignment to non-NULL because of destructor" << LL_ENDL;
+                wild_dtor("Unreference did assignment to non-NULL because of destructor");
                 unref();
             }
         }
     }
-#endif // LL_LIBRARY_INCLUDE
 
 protected:
-    const Type* mPointer;
+    Type*   mPointer;
 };
 
+template <typename Type>
+using LLConstPointer = LLPointer<const Type>;
+
 template<typename Type>
 class LLCopyOnWritePointer : public LLPointer<Type>
 {
@@ -418,14 +276,14 @@ private:
     bool mStayUnique;
 };
 
-template<typename Type>
-bool operator!=(Type* lhs, const LLPointer<Type>& rhs)
+template<typename Type0, typename Type1>
+bool operator!=(Type0* lhs, const LLPointer<Type1>& rhs)
 {
     return (lhs != rhs.get());
 }
 
-template<typename Type>
-bool operator==(Type* lhs, const LLPointer<Type>& rhs)
+template<typename Type0, typename Type1>
+bool operator==(Type0* lhs, const LLPointer<Type1>& rhs)
 {
     return (lhs == rhs.get());
 }
diff --git a/indra/llcommon/llqueuedthread.cpp b/indra/llcommon/llqueuedthread.cpp
index 1c4ac5a7bf..0196a24b18 100644
--- a/indra/llcommon/llqueuedthread.cpp
+++ b/indra/llcommon/llqueuedthread.cpp
@@ -146,7 +146,7 @@ size_t LLQueuedThread::updateQueue(F32 max_time_ms)
         // schedule a call to threadedUpdate for every call to updateQueue
         if (!isQuitting())
         {
-            mRequestQueue.post([=]()
+            mRequestQueue.post([=, this]()
                 {
                     LL_PROFILE_ZONE_NAMED_CATEGORY_THREAD("qt - update");
                     mIdleThread = false;
@@ -474,7 +474,7 @@ void LLQueuedThread::processRequest(LLQueuedThread::QueuedRequest* req)
 #else
                 using namespace std::chrono_literals;
                 auto retry_time = LL::WorkQueue::TimePoint::clock::now() + 16ms;
-                mRequestQueue.post([=]
+                mRequestQueue.post([=, this]
                     {
                         LL_PROFILE_ZONE_NAMED("processRequest - retry");
                         if (LL::WorkQueue::TimePoint::clock::now() < retry_time)
diff --git a/indra/llcommon/lua_function.cpp b/indra/llcommon/lua_function.cpp
index 33666964f7..21a663a003 100644
--- a/indra/llcommon/lua_function.cpp
+++ b/indra/llcommon/lua_function.cpp
@@ -170,7 +170,7 @@ fsyspath source_path(lua_State* L)
     {
         lua_getinfo(L, i, "s", &ar);
     }
-    return ar.source;
+    return { ar.source };
 }
 
 } // namespace lluau
@@ -1108,7 +1108,7 @@ lua_function(source_path, "source_path(): return the source path of the running
 {
     lua_checkdelta(L, 1);
     lluau_checkstack(L, 1);
-    lua_pushstdstring(L, lluau::source_path(L).u8string());
+    lua_pushstdstring(L, lluau::source_path(L));
     return 1;
 }
 
@@ -1119,7 +1119,7 @@ lua_function(source_dir, "source_dir(): return the source directory of the runni
 {
     lua_checkdelta(L, 1);
     lluau_checkstack(L, 1);
-    lua_pushstdstring(L, lluau::source_path(L).parent_path().u8string());
+    lua_pushstdstring(L, fsyspath(lluau::source_path(L).parent_path()));
     return 1;
 }
 
@@ -1132,7 +1132,7 @@ lua_function(abspath, "abspath(path): "
     lua_checkdelta(L);
     auto path{ lua_tostdstring(L, 1) };
     lua_pop(L, 1);
-    lua_pushstdstring(L, (lluau::source_path(L).parent_path() / path).u8string());
+    lua_pushstdstring(L, fsyspath(lluau::source_path(L).parent_path() / path));
     return 1;
 }
 
diff --git a/indra/llcommon/owning_ptr.h b/indra/llcommon/owning_ptr.h
new file mode 100755
index 0000000000..7cf8d3f0ba
--- /dev/null
+++ b/indra/llcommon/owning_ptr.h
@@ -0,0 +1,71 @@
+/**
+ * @file   owning_ptr.h
+ * @author Nat Goodspeed
+ * @date   2024-09-27
+ * @brief  owning_ptr<T> is like std::unique_ptr<T>, but easier to integrate
+ *
+ * $LicenseInfo:firstyear=2024&license=viewerlgpl$
+ * Copyright (c) 2024, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+#if ! defined(LL_OWNING_PTR_H)
+#define LL_OWNING_PTR_H
+
+#include <functional>
+#include <memory>
+
+/**
+ * owning_ptr<T> adapts std::unique_ptr<T> to make it easier to adopt into
+ * older code using dumb pointers.
+ *
+ * Consider a class Outer with a member Thing* mThing. After the constructor,
+ * each time a method wants to assign to mThing, it must test for nullptr and
+ * destroy the previous Thing instance. During Outer's lifetime, mThing is
+ * passed to legacy domain-specific functions accepting plain Thing*. Finally
+ * the destructor must again test for nullptr and destroy the remaining Thing
+ * instance.
+ *
+ * Multiply that by several different Outer members of different types,
+ * possibly with different domain-specific destructor functions.
+ *
+ * Dropping std::unique_ptr<Thing> into Outer is cumbersome for a several
+ * reasons. First, if Thing requires a domain-specific destructor function,
+ * the unique_ptr declaration of mThing must explicitly state the type of that
+ * function (as a function pointer, for a typical legacy function). Second,
+ * every Thing* assignment to mThing must be changed to mThing.reset(). Third,
+ * every time we call a legacy domain-specific function, we must pass
+ * mThing.get().
+ *
+ * owning_ptr<T> is designed to drop into a situation like this. The domain-
+ * specific destructor function, if any, is passed to its constructor; it need
+ * not be encoded into the pointer type. owning_ptr<T> supports plain pointer
+ * assignment, internally calling std::unique_ptr<T>::reset(). It also
+ * supports implicit conversion to plain T*, to pass the owned pointer to
+ * legacy domain-specific functions.
+ *
+ * Obviously owning_ptr<T> must not be used in situations where ownership of
+ * the referenced object is passed on to another pointer: use std::unique_ptr
+ * for that. Similarly, it is not for shared ownership. It simplifies lifetime
+ * management for classes that currently store (and explicitly destroy) plain
+ * T* pointers.
+ */
+template <typename T>
+class owning_ptr
+{
+    using deleter = std::function<void(T*)>;
+public:
+    owning_ptr(T* p=nullptr, const deleter& d=std::default_delete<T>()):
+        mPtr(p, d)
+    {}
+    void reset(T* p=nullptr) { mPtr.reset(p); }
+    owning_ptr& operator=(T* p) { mPtr.reset(p); return *this; }
+    operator T*() const { return mPtr.get(); }
+    T& operator*() const { return *mPtr; }
+    T* operator->() const { return mPtr.operator->(); }
+
+private:
+    std::unique_ptr<T, deleter> mPtr;
+};
+
+#endif /* ! defined(LL_OWNING_PTR_H) */
diff --git a/indra/llcommon/workqueue.cpp b/indra/llcommon/workqueue.cpp
index 9138c862f9..8b7b97a1f9 100644
--- a/indra/llcommon/workqueue.cpp
+++ b/indra/llcommon/workqueue.cpp
@@ -127,9 +127,7 @@ void LL::WorkQueueBase::error(const std::string& msg)
 
 void LL::WorkQueueBase::checkCoroutine(const std::string& method)
 {
-    // By convention, the default coroutine on each thread has an empty name
-    // string. See also LLCoros::logname().
-    if (LLCoros::getName().empty())
+    if (LLCoros::on_main_coro())
     {
         LLTHROW(Error("Do not call " + method + " from a thread's default coroutine"));
     }