removed explicit calls to malloc/free

Lane and linda userdata were allocated with malloc/free, preventing embedders from fully controlling memory operations. Now all internal Lanes allocations go through the master state alloc function.

5 files changed, 46 insertions, 30 deletions

diff --git a/CHANGES b/CHANGES
index 0aca28a..2aca378 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,5 +1,8 @@
 CHANGES:
 
+CHANGE 151: BGe 7-Feb-22
+   * Lanes no longer relies on malloc/free for internal allocations, but uses the primary alloc function from the master Lua state
+
 CHANGE 150: BGe 22-Sep-21
    * fix require() wrapper to return all values returned by original require()
 
diff --git a/src/lanes.c b/src/lanes.c
index c5b6c4f..8817071 100644
--- a/src/lanes.c
+++ b/src/lanes.c
@@ -238,6 +238,7 @@ static bool_t tracking_remove( Lane* s)
 
 static void lane_cleanup( Lane* s)
 {
+    AllocatorDefinition* const allocD = &s->U->protected_allocator.definition;
     // Clean up after a (finished) thread
     //
 #if THREADWAIT_METHOD == THREADWAIT_CONDVAR
@@ -253,7 +254,7 @@ static void lane_cleanup( Lane* s)
     }
 #endif // HAVE_LANE_TRACKING
 
-    free( s);
+    allocD->allocF(allocD->allocUD, s, sizeof(Lane), 0);
 }
 
 /*
@@ -457,9 +458,9 @@ static int selfdestruct_gc( lua_State* L)
                 // if we failed, and we know the thread is waiting on a linda
                 if( cancelled == FALSE && s->status == WAITING && s->waiting_on != NULL)
                 {
-                    // signal the linda the wake up the thread so that it can react to the cancel query
+                    // signal the linda to wake up the thread so that it can react to the cancel query
                     // let us hope we never land here with a pointer on a linda that has been destroyed...
-                    SIGNAL_T *waiting_on = s->waiting_on;
+                    SIGNAL_T* waiting_on = s->waiting_on;
                     //s->waiting_on = NULL; // useful, or not?
                     SIGNAL_ALL( waiting_on);
                 }
@@ -1053,6 +1054,7 @@ LUAG_FUNC( lane_new)
 #define FIXED_ARGS 7
     int const nargs = lua_gettop(L) - FIXED_ARGS;
     Universe* U = universe_get( L);
+    AllocatorDefinition* const allocD = &U->protected_allocator.definition;
     ASSERT_L( nargs >= 0);
 
     // public Lanes API accepts a generic range -3/+3
@@ -1222,7 +1224,7 @@ LUAG_FUNC( lane_new)
     //
     // a Lane full userdata needs a single uservalue
     ud = lua_newuserdatauv( L, sizeof( Lane*), 1);           // func libs priority globals package required gc_cb lane
-    s = *ud = (Lane*) malloc( sizeof( Lane));
+    s = *ud = (Lane*) allocD->allocF( allocD->allocUD, NULL, 0, sizeof(Lane));
     if( s == NULL)
     {
         return luaL_error( L, "could not create lane: out of memory");
@@ -1856,7 +1858,7 @@ LUAG_FUNC( configure)
 #endif // THREADAPI == THREADAPI_PTHREAD
 
     STACK_GROW( L, 4);
-    STACK_CHECK_ABS( L, 1);                                                              // settings
+    STACK_CHECK_ABS( L, 1);                                                                // settings
 
     DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%p: lanes.configure() BEGIN\n" INDENT_END, L));
     DEBUGSPEW_CODE( if( U) ++ U->debugspew_indent_depth);
@@ -1913,10 +1915,10 @@ LUAG_FUNC( configure)
     serialize_require( DEBUGSPEW_PARAM_COMMA( U) L);
 
     // Retrieve main module interface table
-    lua_pushvalue( L, lua_upvalueindex( 2));                                             // settings M
+    lua_pushvalue( L, lua_upvalueindex( 2));                                               // settings M
     // remove configure() (this function) from the module interface
-    lua_pushnil( L);                                                                     // settings M nil
-    lua_setfield( L, -2, "configure");                                                   // settings M
+    lua_pushnil( L);                                                                       // settings M nil
+    lua_setfield( L, -2, "configure");                                                     // settings M
     // add functions to the module's table
     luaG_registerlibfuncs( L, lanes_functions);
 #if HAVE_LANE_TRACKING
@@ -1943,7 +1945,7 @@ LUAG_FUNC( configure)
     // prepare the metatable for threads
     // contains keys: { __gc, __index, cached_error, cached_tostring, cancel, join, get_debug_threadname }
     //
-    if( luaL_newmetatable( L, "Lane"))                                                   // settings M mt
+    if( luaL_newmetatable( L, "Lane"))                                                     // settings M mt
     {
         lua_pushcfunction( L, LG_thread_gc);                                               // settings M mt LG_thread_gc
         lua_setfield( L, -2, "__gc");                                                      // settings M mt
@@ -1965,25 +1967,25 @@ LUAG_FUNC( configure)
         lua_setfield( L, -2, "__metatable");                                               // settings M mt
     }
 
-    lua_pushcclosure( L, LG_lane_new, 1);                                                // settings M lane_new
-    lua_setfield( L, -2, "lane_new");                                                    // settings M
+    lua_pushcclosure( L, LG_lane_new, 1);                                                  // settings M lane_new
+    lua_setfield( L, -2, "lane_new");                                                      // settings M
 
     // we can't register 'lanes.require' normally because we want to create an upvalued closure
-    lua_getglobal( L, "require");                                                        // settings M require
-    lua_pushcclosure( L, LG_require, 1);                                                 // settings M lanes.require
-    lua_setfield( L, -2, "require");                                                     // settings M
+    lua_getglobal( L, "require");                                                          // settings M require
+    lua_pushcclosure( L, LG_require, 1);                                                   // settings M lanes.require
+    lua_setfield( L, -2, "require");                                                       // settings M
 
     lua_pushfstring(
         L, "%d.%d.%d"
         , LANES_VERSION_MAJOR, LANES_VERSION_MINOR, LANES_VERSION_PATCH
-    );                                                                                   // settings M VERSION
-    lua_setfield( L, -2, "version");                                                     // settings M
+    );                                                                                     // settings M VERSION
+    lua_setfield( L, -2, "version");                                                       // settings M
 
-    lua_pushinteger(L, THREAD_PRIO_MAX);                                                 // settings M THREAD_PRIO_MAX
-    lua_setfield( L, -2, "max_prio");                                                    // settings M
+    lua_pushinteger(L, THREAD_PRIO_MAX);                                                   // settings M THREAD_PRIO_MAX
+    lua_setfield( L, -2, "max_prio");                                                      // settings M
 
-    push_unique_key( L, CANCEL_ERROR);                                                   // settings M CANCEL_ERROR
-    lua_setfield( L, -2, "cancel_error");                                                // settings M
+    push_unique_key( L, CANCEL_ERROR);                                                     // settings M CANCEL_ERROR
+    lua_setfield( L, -2, "cancel_error");                                                  // settings M
 
     STACK_MID( L, 2); // reference stack contains only the function argument 'settings'
     // we'll need this every time we transfer some C function from/to this state
diff --git a/src/linda.c b/src/linda.c
index a9c9710..21b38fe 100644
--- a/src/linda.c
+++ b/src/linda.c
@@ -758,6 +758,9 @@ LUAG_FUNC( linda_towatch)
 */
 static void* linda_id( lua_State* L, DeepOp op_)
 {
+    Universe* const U = universe_get(L);
+    AllocatorDefinition* const allocD = &U->protected_allocator.definition;
+
     switch( op_)
     {
         case eDO_new:
@@ -794,7 +797,7 @@ static void* linda_id( lua_State* L, DeepOp op_)
             * One can use any memory allocation scheme.
             * just don't use L's allocF because we don't know which state will get the honor of GCing the linda
             */
-            s = (struct s_Linda*) malloc( sizeof(struct s_Linda) + name_len); // terminating 0 is already included
+            s = (struct s_Linda*) allocD->allocF( allocD->allocUD, NULL, 0, sizeof(struct s_Linda) + name_len); // terminating 0 is already included
             if( s)
             {
                 s->prelude.magic.value = DEEP_VERSION.value;
@@ -827,7 +830,7 @@ static void* linda_id( lua_State* L, DeepOp op_)
             // There aren't any lanes waiting on these lindas, since all proxies have been gc'ed. Right?
             SIGNAL_FREE( &linda->read_happened);
             SIGNAL_FREE( &linda->write_happened);
-            free( linda);
+            allocD->allocF( allocD->allocUD, linda, sizeof(struct s_Linda) + strlen(linda->name), 0);
             return NULL;
         }
 
diff --git a/src/tools.c b/src/tools.c
index acb78e6..e72d441 100644
--- a/src/tools.c
+++ b/src/tools.c
@@ -174,11 +174,12 @@ static int luaG_provide_protected_allocator( lua_State* L)
     return 1;
 }
 
+// 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 initialize_allocator_function( Universe* U, lua_State* L)
 {
     STACK_CHECK( L, 0);
-    lua_getfield( L, -1, "allocator");                    // settings allocator|nil|"protected"
+    lua_getfield( L, -1, "allocator");                      // settings allocator|nil|"protected"
     if( !lua_isnil( L, -1))
     {
         // store C function pointer in an internal variable
@@ -186,17 +187,17 @@ void initialize_allocator_function( Universe* U, lua_State* L)
         if( U->provide_allocator != NULL)
         {
             // make sure the function doesn't have upvalues
-            char const* upname = lua_getupvalue( L, -1, 1);   // settings allocator upval?
+            char const* upname = lua_getupvalue( L, -1, 1); // settings allocator upval?
             if( upname != NULL) // should be "" for C functions with upvalues if any
             {
                 (void) luaL_error( L, "config.allocator() shouldn't have upvalues");
             }
             // 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);                                  // settings allocator nil
-            lua_setfield( L, -3, "allocator");                // settings allocator
+            lua_pushnil( L);                                // settings allocator nil
+            lua_setfield( L, -3, "allocator");              // settings allocator
         }
-        else if( lua_type( L, -1) == LUA_TSTRING)
+        else if( lua_type( L, -1) == LUA_TSTRING) // should be "protected"
         {
             // initialize all we need for the protected allocator
             MUTEX_INIT( &U->protected_allocator.lock); // the mutex
@@ -208,7 +209,14 @@ void initialize_allocator_function( Universe* U, lua_State* L)
             lua_setallocf( L, protected_lua_Alloc, &U->protected_allocator);
         }
     }
-    lua_pop( L, 1);                                       // settings
+    else
+    {
+        // initialize the mutex even if we are not going to use it, because cleanup_allocator_function will deinitialize it
+        MUTEX_INIT( &U->protected_allocator.lock);
+        // just grab whatever allocator was provided to lua_newstate
+        U->protected_allocator.definition.allocF = lua_getallocf( L, &U->protected_allocator.definition.allocUD);
+    }
+    lua_pop( L, 1);                                         // settings
     STACK_END( L, 0);
 }
 
diff --git a/src/universe.h b/src/universe.h
index 248a117..e4c1191 100644
--- a/src/universe.h
+++ b/src/universe.h
@@ -42,7 +42,7 @@ typedef struct ProtectedAllocator_s ProtectedAllocator;
 
 // ################################################################################################
 
-// everything regarding the a Lanes universe is stored in that global structure
+// everything regarding the Lanes universe is stored in that global structure
 // held as a full userdata in the master Lua state that required it for the first time
 // don't forget to initialize all members in LG_configure()
 struct s_Universe
@@ -58,7 +58,7 @@ struct s_Universe
     // after a state is created, this function will be called right after the bases libraries are loaded
     lua_CFunction on_state_create_func;
 
-    // Initialized and used only if allocator="protected" is found in the configuration settings
+    // if allocator="protected" is found in the configuration settings, a wrapper allocator will protect all allocator calls with a mutex
     // contains a mutex and the original allocator definition
     ProtectedAllocator protected_allocator;