1 files changed, 96 insertions, 41 deletions

diff --git a/src/universe.cpp b/src/universe.cpp
index 3da0801..4db036b 100644
--- a/src/universe.cpp
+++ b/src/universe.cpp
@@ -51,6 +51,16 @@ static constexpr RegistryUniqueKey kUniverseFullRegKey{ 0x1C2D76870DD9DD9Full };
 
 // #################################################################################################
 
+[[nodiscard]]
+void* ProtectedAllocator::Protected_lua_Alloc(void* const ud_, void* const ptr_, size_t const osize_, size_t const nsize_)
+{
+    ProtectedAllocator* const _allocator{ static_cast<ProtectedAllocator*>(ud_) };
+    std::lock_guard<std::mutex> _guard{ _allocator->mutex };
+    return _allocator->alloc(ptr_, osize_, nsize_);
+}
+
+// #################################################################################################
+
 Universe::Universe()
 {
     //---
@@ -101,18 +111,18 @@ void Universe::callOnStateCreate(lua_State* const L_, lua_State* const from_, Lo
         }
         kConfigRegKey.pushValue(L_);                                                               // L_: config
         STACK_CHECK(L_, 1);
-        LuaType const _funcType{ luaG_getfield(L_, kIdxTop, kOnStateCreate) };                     // L_: config on_state_create()
+        LuaType const _funcType{ luaW_getfield(L_, kIdxTop, kOnStateCreate) };                     // L_: config on_state_create()
         if (_funcType != LuaType::FUNCTION) {
-            raise_luaL_error(L_, "INTERNAL ERROR: %s is a %s, not a function", kOnStateCreate.data(), luaG_typename(L_, _funcType).data());
+            raise_luaL_error(L_, "INTERNAL ERROR: %s is a %s, not a function", kOnStateCreate.data(), luaW_typename(L_, _funcType).data());
         }
         lua_remove(L_, -2);                                                                        // L_: on_state_create()
     }
     STACK_CHECK(L_, 1);
     // capture error and raise it in caller state
     std::string_view const _stateType{ mode_ == LookupMode::LaneBody ? "lane" : "keeper" };
-    luaG_pushstring(L_, _stateType);                                                               // L_: on_state_create() "<type>"
+    luaW_pushstring(L_, _stateType);                                                               // L_: on_state_create() "<type>"
     if (lua_pcall(L_, 1, 0, 0) != LUA_OK) {
-        raise_luaL_error(from_, "%s failed in %s: \"%s\"", kOnStateCreate.data(), _stateType.data(), lua_isstring(L_, -1) ? luaG_tostring(L_, kIdxTop).data() : luaG_typename(L_, kIdxTop).data());
+        raise_luaL_error(from_, "%s failed in %s: \"%s\"", kOnStateCreate.data(), _stateType.data(), lua_isstring(L_, -1) ? luaW_tostring(L_, kIdxTop).data() : luaW_typename(L_, kIdxTop).data());
     }
     STACK_CHECK(L_, 0);
 }
@@ -127,14 +137,14 @@ Universe* Universe::Create(lua_State* const L_)
     static constexpr StackIndex kIdxSettings{ 1 };
     LUA_ASSERT(L_, lua_gettop(L_) == 1 && lua_istable(L_, 1));
     STACK_CHECK_START_REL(L_, 0);                                                                  // L_: settings
-    std::ignore = luaG_getfield(L_, kIdxSettings, "nb_user_keepers");                              // L_: settings nb_user_keepers
+    std::ignore = luaW_getfield(L_, kIdxSettings, "nb_user_keepers");                              // L_: settings nb_user_keepers
     int const _nbUserKeepers{ static_cast<int>(lua_tointeger(L_, -1)) + 1};
     lua_pop(L_, 1);                                                                                // L_: settings
     if (_nbUserKeepers < 1) {
         raise_luaL_error(L_, "Bad number of additional keepers (%d)", _nbUserKeepers);
     }
     STACK_CHECK(L_, 0);
-    std::ignore = luaG_getfield(L_, kIdxSettings, "keepers_gc_threshold");                         // L_: settings keepers_gc_threshold
+    std::ignore = luaW_getfield(L_, kIdxSettings, "keepers_gc_threshold");                         // L_: settings keepers_gc_threshold
     int const _keepers_gc_threshold{ static_cast<int>(lua_tointeger(L_, -1)) };
     lua_pop(L_, 1);                                                                                // L_: settings
     STACK_CHECK(L_, 0);
@@ -147,22 +157,30 @@ Universe* Universe::Create(lua_State* const L_)
 
     DEBUGSPEW_CODE(DebugSpewIndentScope _scope{ _U });
     lua_createtable(L_, 0, 1);                                                                     // L_: settings universe {mt}
-    std::ignore = luaG_getfield(L_, kIdxSettings, "shutdown_timeout");                             // L_: settings universe {mt} shutdown_timeout
+    std::ignore = luaW_getfield(L_, kIdxSettings, "shutdown_timeout");                             // L_: settings universe {mt} shutdown_timeout
     lua_pushcclosure(L_, UniverseGC, 1);                                                           // L_: settings universe {mt} UniverseGC
     lua_setfield(L_, -2, "__gc");                                                                  // L_: settings universe {mt}
     lua_setmetatable(L_, -2);                                                                      // L_: settings universe
     lua_pop(L_, 1);                                                                                // L_: settings
 
-    std::ignore = luaG_getfield(L_, kIdxSettings, "strip_functions");                              // L_: settings strip_functions
+    std::ignore = luaW_getfield(L_, kIdxSettings, "linda_wake_period");                            // L_: settings linda_wake_period
+    if (luaW_type(L_, kIdxTop) == LuaType::NUMBER) {
+        _U->lindaWakePeriod = lua_Duration{ lua_tonumber(L_, kIdxTop) };
+    } else {
+        LUA_ASSERT(L_, luaW_tostring(L_, kIdxTop) == "never");
+    }
+    lua_pop(L_, 1);                                                                                // L_: settings
+
+    std::ignore = luaW_getfield(L_, kIdxSettings, "strip_functions");                              // L_: settings strip_functions
     _U->stripFunctions = lua_toboolean(L_, -1) ? true : false;
     lua_pop(L_, 1);                                                                                // L_: settings
 
-    std::ignore = luaG_getfield(L_, kIdxSettings, "verbose_errors");                               // L_: settings verbose_errors
+    std::ignore = luaW_getfield(L_, kIdxSettings, "verbose_errors");                               // L_: settings verbose_errors
     _U->verboseErrors = lua_toboolean(L_, -1) ? true : false;
     lua_pop(L_, 1);                                                                                // L_: settings
 
     // tracking
-    std::ignore = luaG_getfield(L_, kIdxSettings, "track_lanes");                                  // L_: settings track_lanes
+    std::ignore = luaW_getfield(L_, kIdxSettings, "track_lanes");                                  // L_: settings track_lanes
     if (lua_toboolean(L_, -1)) {
         _U->tracker.activate();
     }
@@ -170,8 +188,8 @@ Universe* Universe::Create(lua_State* const L_)
 
     // Linked chains handling
     _U->selfdestructFirst = SELFDESTRUCT_END;
-    _U->initializeAllocatorFunction(L_);
-    _U->initializeOnStateCreate(L_);
+    _U->initializeAllocatorFunction(L_); // this can raise an error
+    _U->initializeOnStateCreate(L_); // this can raise an error
     _U->keepers.initialize(*_U, L_, static_cast<size_t>(_nbUserKeepers), _keepers_gc_threshold);
     STACK_CHECK(L_, 0);
 
@@ -199,7 +217,7 @@ static void* libc_lua_Alloc([[maybe_unused]] void* const ud_, [[maybe_unused]] v
 // #################################################################################################
 
 [[nodiscard]]
-static int luaG_provide_protected_allocator(lua_State* const L_)
+static int luaW_provide_protected_allocator(lua_State* const L_)
 {
     Universe* const _U{ Universe::Get(L_) };
     // push a new full userdata on the stack, giving access to the universe's protected allocator
@@ -209,6 +227,17 @@ static int luaG_provide_protected_allocator(lua_State* const L_)
 
 // #################################################################################################
 
+// already called under protection of selfdestructMutex
+void Universe::flagDanglingLanes() const
+{
+    Lane* _lane{ selfdestructFirst };
+    while (_lane != SELFDESTRUCT_END) {
+        _lane->flaggedAfterUniverseGC.store(true, std::memory_order_relaxed);
+        _lane = _lane->selfdestruct_next;
+    }
+}
+// #################################################################################################
+
 // called once at the creation of the universe (therefore L_ is the master Lua state everything originates from)
 // Do I need to disable this when compiling for LuaJIT to prevent issues?
 void Universe::initializeAllocatorFunction(lua_State* const L_)
@@ -216,24 +245,24 @@ void Universe::initializeAllocatorFunction(lua_State* const L_)
     // start by just grabbing whatever allocator was provided to the master state
     protectedAllocator.initFrom(L_);
     STACK_CHECK_START_REL(L_, 1);                                                                  // L_: settings
-    switch (luaG_getfield(L_, kIdxTop, "allocator")) {                                             // L_: settings allocator|nil|"protected"
+    switch (luaW_getfield(L_, kIdxTop, "allocator")) {                                             // L_: settings allocator|nil|"protected"
     case LuaType::NIL:
         // nothing else to do
         break;
 
     case LuaType::STRING:
-        LUA_ASSERT(L_, luaG_tostring(L_, kIdxTop) == "protected");
+        LUA_ASSERT(L_, luaW_tostring(L_, kIdxTop) == "protected");
         // set the original allocator to call from inside protection by the mutex
         protectedAllocator.installIn(L_);
         // before a state is created, this function will be called to obtain the allocator
-        provideAllocator = luaG_provide_protected_allocator;
+        provideAllocator = luaW_provide_protected_allocator;
         break;
 
     case LuaType::FUNCTION:
         provideAllocator = lua_tocfunction(L_, -1);                                                // L_: settings allocator
         if (provideAllocator != nullptr) {
             // make sure the function doesn't have upvalues
-            char const* _upname = lua_getupvalue(L_, -1, 1);                                       // L_: settings allocator upval?
+            char const* _upname{ lua_getupvalue(L_, -1, 1) };                                      // L_: settings allocator upval?
             if (_upname != nullptr) {   // should be "" for C functions with upvalues if any
                 raise_luaL_error(L_, "config.allocator() shouldn't have upvalues");
             }
@@ -247,19 +276,19 @@ void Universe::initializeAllocatorFunction(lua_State* const L_)
         break;
 
     default: // should be filtered out in lanes.lua
-        raise_luaL_error(L_, "Bad config.allocator type %s", luaG_typename(L_, kIdxTop).data());
+        raise_luaL_error(L_, "Bad config.allocator type %s", luaW_typename(L_, kIdxTop).data());
     }
     lua_pop(L_, 1);                                                                                // L_: settings
     STACK_CHECK(L_, 1);
 
-    std::ignore = luaG_getfield(L_, kIdxTop, "internal_allocator");                                // L_: settings "libc"|"allocator"
+    std::ignore = luaW_getfield(L_, kIdxTop, "internal_allocator");                                // L_: settings "libc"|"allocator"
     LUA_ASSERT(L_, lua_isstring(L_, kIdxTop)); // should be the case due to lanes.lua parameter validation
-    std::string_view const _allocator{ luaG_tostring(L_, kIdxTop) };
+    std::string_view const _allocator{ luaW_tostring(L_, kIdxTop) };
+    // use whatever the provider provides. This performs validation of what provideAllocator is giving
+    // we do this even if _allocator == "libc", to have the validation part
+    internalAllocator = resolveAndValidateAllocator(L_, "internal");
     if (_allocator == "libc") {
         internalAllocator = lanes::AllocatorDefinition{ libc_lua_Alloc, nullptr };
-    } else {
-        // use whatever the provider provides
-        internalAllocator = resolveAllocator(L_, "internal");
     }
     lua_pop(L_, 1);                                                                                // L_: settings
     STACK_CHECK(L_, 1);
@@ -276,7 +305,7 @@ int Universe::InitializeFinalizer(lua_State* const L_)
 
     // make sure we are only called from the Master Lua State!
     kUniverseFullRegKey.pushValue(L_);                                                             // L_: f U
-    if (luaG_type(L_, kIdxTop) != LuaType::USERDATA) {
+    if (luaW_type(L_, kIdxTop) != LuaType::USERDATA) {
         raise_luaL_error(L_, "lanes.%s called from inside a lane", kFinally);
     }
     lua_pop(L_, 1);                                                                                // L_: f
@@ -292,8 +321,8 @@ int Universe::InitializeFinalizer(lua_State* const L_)
 void Universe::initializeOnStateCreate(lua_State* const L_)
 {
     STACK_CHECK_START_REL(L_, 0);                                                                  // L_: settings
-    if (luaG_getfield(L_, kIdxTop, kOnStateCreate) != LuaType::NIL) {                              // L_: settings on_state_create|nil
-        LUA_ASSERT(L_, luaG_type(L_, kIdxTop) == LuaType::FUNCTION); // ensured by lanes.lua parameter validation
+    if (luaW_getfield(L_, kIdxTop, kOnStateCreate) != LuaType::NIL) {                              // L_: settings on_state_create|nil
+        LUA_ASSERT(L_, luaW_type(L_, kIdxTop) == LuaType::FUNCTION); // ensured by lanes.lua parameter validation
         // store C function pointer in an internal variable
         lua_CFunction const _func{ lua_tocfunction(L_, -1) };                                      // L_: settings on_state_create
         if (_func) {
@@ -306,7 +335,7 @@ void Universe::initializeOnStateCreate(lua_State* const L_)
             // remove this C function from the config table so that it doesn't cause problems
             // when we transfer the config table in newly created Lua states
             lua_pushnil(L_);                                                                       // L_: settings on_state_create nil
-            luaG_setfield(L_, StackIndex{ -3 }, kOnStateCreate);                                   // L_: settings on_state_create
+            luaW_setfield(L_, StackIndex{ -3 }, kOnStateCreate);                                   // L_: settings on_state_create
         } else {
             // the function is still in the config table. we indicate this with the uintptr_t alternative (actual value is irrelevant)
             onStateCreateFunc.emplace<uintptr_t>(std::bit_cast<uintptr_t>(kOnStateCreate.data()));
@@ -320,7 +349,7 @@ void Universe::initializeOnStateCreate(lua_State* const L_)
 
 // #################################################################################################
 
-lanes::AllocatorDefinition Universe::resolveAllocator(lua_State* const L_, std::string_view const& hint_) const
+lanes::AllocatorDefinition Universe::resolveAndValidateAllocator(lua_State* const L_, std::string_view const& hint_) const
 {
     lanes::AllocatorDefinition _ret{ protectedAllocator };
     if (provideAllocator == nullptr) {
@@ -329,7 +358,7 @@ lanes::AllocatorDefinition Universe::resolveAllocator(lua_State* const L_, std::
 
     STACK_CHECK_START_REL(L_, 0); // here, we have a function we can call to obtain an allocator
     lua_pushcclosure(L_, provideAllocator, 0);                                                     // L_: provideAllocator()
-    luaG_pushstring(L_, hint_);                                                                    // L_: provideAllocator() "<hint>"
+    luaW_pushstring(L_, hint_);                                                                    // L_: provideAllocator() "<hint>"
     lua_call(L_, 1, 1);                                                                            // L_: result
     // make sure we have a valid AllocatorDefinition on the stack (an error is raised instead if it is not the case)
     _ret = lanes::AllocatorDefinition::Validated(L_, kIdxTop);
@@ -399,11 +428,12 @@ bool Universe::terminateFreeRunningLanes(lua_Duration const shutdownTimeout_, Ca
 // #################################################################################################
 
 // process end: cancel any still free-running threads
+// as far as I can tell, this can only by called only from lua_close()
 int Universe::UniverseGC(lua_State* const L_)
 {
     lua_Duration const _shutdown_timeout{ lua_tonumber(L_, lua_upvalueindex(1)) };
     STACK_CHECK_START_ABS(L_, 1);
-    Universe* const _U{ luaG_tofulluserdata<Universe>(L_, StackIndex{ 1 }) };                      // L_: U
+    Universe* const _U{ luaW_tofulluserdata<Universe>(L_, StackIndex{ 1 }) };                      // L_: U
 
     // attempt to terminate all lanes with increasingly stronger cancel methods
     bool const _allLanesTerminated{ 
@@ -416,27 +446,52 @@ int Universe::UniverseGC(lua_State* const L_)
     kFinalizerRegKey.pushValue(L_);                                                                // L_: U finalizer|nil
     if (!lua_isnil(L_, -1)) {
         lua_pushboolean(L_, _allLanesTerminated);                                                  // L_: U finalizer bool
-        // no protection. Lua rules for errors in finalizers apply normally
-        lua_call(L_, 1, 1);                                                                        // L_: U ret|error
+        // no protection. Lua rules for errors in finalizers apply normally:
+        // Lua 5.4+: error is propagated in the warn system
+        // older: error is swallowed
+        lua_call(L_, 1, 1);                                                                        // L_: U msg?
+        // phew, no error in finalizer, since we reached that point
     }
-    STACK_CHECK(L_, 2);
 
-    // if some lanes are still running here, we have no other choice than crashing or freezing and let the client figure out what's wrong
-    bool const _throw{ luaG_tostring(L_, kIdxTop) == "throw" };
-    lua_pop(L_, 1);                                                                                // L_: U
+    if (lua_isnil(L_, kIdxTop)) {
+        lua_pop(L_, 1);                                                                            // L_: U
+        // no finalizer, or it returned no value: push some default message on the stack, in case it is necessary
+        luaW_pushstring(L_, "uncooperative lanes detected at shutdown");                           // L_: U "msg"
+    }
+    STACK_CHECK(L_, 2);
 
-    while (_U->selfdestructFirst != SELFDESTRUCT_END) {
-        if (_throw) {
-            throw std::logic_error{ "Some lanes are still running at shutdown" };
+    {
+        std::lock_guard<std::mutex> _guard{ _U->selfdestructMutex };
+        // now, all remaining lanes are flagged. if they crash because we remove keepers and the Universe from under them, it is their fault
+        bool const _detectedUncooperativeLanes{ _U->selfdestructFirst != SELFDESTRUCT_END };
+        if (_detectedUncooperativeLanes) {
+            _U->flagDanglingLanes();
+            if (luaW_tostring(L_, kIdxTop) == "freeze") {
+                std::this_thread::sleep_until(std::chrono::time_point<std::chrono::steady_clock>::max());
+            } else {
+                // take the value returned by the finalizer (or our default message) and throw it as an error
+                // since we are inside Lua's GCTM, it will be propagated through the warning system (Lua 5.4) or swallowed silently
+                // IMPORTANT: lua_error() is used here instead of the wrapper raise_lua_error() to circumvent what looks like a MSVC compiler bug
+                // that manifests as a crash inside ntdll!longjmp() function, in optimized builds only
+                lua_error(L_);
+            }
         } else {
-            std::this_thread::yield();
+            // we didn't use the error message, let's keep a clean stack
+            lua_pop(L_, 1); // L_: U
         }
     }
+    STACK_CHECK(L_, 1);
+
+    // ---------------------------------------------------------
+    // we don't reach that point if some lanes are still running
+    // ---------------------------------------------------------
 
     // no need to mutex-protect this as all lanes in the universe are gone at that point
     Linda::DeleteTimerLinda(L_, std::exchange(_U->timerLinda, nullptr), PK);
 
-    _U->keepers.close();
+    if (!_U->keepers.close()) {
+        raise_luaL_error(L_, "INTERNAL ERROR: Keepers closed more than once");
+    }
 
     // remove the protected allocator, if any
     _U->protectedAllocator.removeFrom(L_);