6 files changed, 102 insertions, 61 deletions

diff --git a/CHANGES b/CHANGES
index e7a08f7..4a1ce49 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,5 +1,12 @@
 CHANGES:
 
+CHANGE 101: BGe 18-Feb-14
+   * version 3.9.1
+   * removed some keeper desinit legacy dead code
+   * keeper array is allocated with master state's alloc function instead of malloc()/free()
+   * prevent application crash when specifying a very large number of keepers in the configuration options
+   * any error occuring during one-time inits is raised outside the one-time mutex protected code region
+
 CHANGE 100: BGe 17-Feb-14
    * lanes.linda() accepts an optional integer group to give control on keeper state repartition
 
diff --git a/src/keeper.c b/src/keeper.c
index 9b77c75..0f54e13 100644
--- a/src/keeper.c
+++ b/src/keeper.c
@@ -580,11 +580,7 @@ int keepercall_count( lua_State* L)
 static struct s_Keeper *GKeepers = NULL;
 static int GNbKeepers = 0;
 
-#if HAVE_KEEPER_ATEXIT_DESINIT
-static void atexit_close_keepers( void)
-#else // HAVE_KEEPER_ATEXIT_DESINIT
-void close_keepers( void)
-#endif // HAVE_KEEPER_ATEXIT_DESINIT
+void close_keepers( lua_State* L)
 {
         int i;
         int const nbKeepers = GNbKeepers;
@@ -604,25 +600,29 @@ void close_keepers( void)
         }
         if( GKeepers != NULL)
         {
-                free( GKeepers);
+                void* allocUD;
+                lua_Alloc allocF = lua_getallocf( L, &allocUD);
+                allocF( allocUD, GKeepers, nbKeepers * sizeof( struct s_Keeper), 0);
         }
         GKeepers = NULL;
 }
 
 /*
-* Initialize keeper states
-*
-* If there is a problem, return an error message (NULL for okay).
-*
-* Note: Any problems would be design flaws; the created Lua state is left
-*       unclosed, because it does not really matter. In production code, this
-*       function never fails.
-* settings table is at position 1 on the stack
-*/
-char const* init_keepers( lua_State* L)
+ * Initialize keeper states
+ *
+ * If there is a problem, return an error message (NULL for okay).
+ *
+ * Note: Any problems would be design flaws; the created Lua state is left
+ *       unclosed, because it does not really matter. In production code, this
+ *       function never fails.
+ * settings table is at position 1 on the stack
+ * pushes an error string on the stack in case of problem
+ */
+int init_keepers( lua_State* L)
 {
         int i;
-        PROPAGATE_ALLOCF_PREP( L);
+        void* allocUD;
+        lua_Alloc allocF = lua_getallocf( L, &allocUD);
 
         STACK_CHECK( L);                                       // L                            K
         lua_getfield( L, 1, "nb_keepers");                     // nb_keepers
@@ -630,13 +630,21 @@ char const* init_keepers( lua_State* L)
         lua_pop( L, 1);                                        //
         assert( GNbKeepers >= 1);
 
-        GKeepers = malloc( GNbKeepers * sizeof( struct s_Keeper));
+        GKeepers = (struct s_Keeper*) allocF( allocUD, NULL, 0, GNbKeepers * sizeof( struct s_Keeper));
+        if( GKeepers == NULL)
+        {
+                lua_pushliteral( L, "init_keepers() failed while creating keeper array; out of memory");
+                STACK_MID( L, 1);
+                return 1;
+        }
         for( i = 0; i < GNbKeepers; ++ i)
         {
                 lua_State* K = PROPAGATE_ALLOCF_ALLOC();
                 if( K == NULL)
                 {
-                        (void) luaL_error( L, "init_keepers() failed while creating keeper state; out of memory");
+                        lua_pushliteral( L, "init_keepers() failed while creating keeper states; out of memory");
+                        STACK_MID( L, 1);
+                        return 1;
                 }
                 STACK_CHECK( K);
 
@@ -652,14 +660,26 @@ char const* init_keepers( lua_State* L)
                 lua_getglobal( L, "package");                        // package
                 if( !lua_isnil( L, -1))
                 {
-                        luaG_inter_copy_package( L, K, -1, eLM_ToKeeper);
+                        // when copying with mode eLM_ToKeeper, error message is pushed at the top of the stack, not raised immediately
+                        if( luaG_inter_copy_package( L, K, -1, eLM_ToKeeper))
+                        {
+                                // if something went wrong, the error message is at the top of the stack
+                                lua_remove( L, -2);                              // error_msg
+                                STACK_MID( L, 1);
+                                return 1;
+                        }
                 }
                 lua_pop( L, 1);                                      //
                 STACK_MID( L, 0);
 
                 // attempt to call on_state_create(), if we have one and it is a C function
                 // (only support a C function because we can't transfer executable Lua code in keepers)
-                call_on_state_create( K, L, eLM_ToKeeper);
+                if( call_on_state_create( K, L, eLM_ToKeeper))
+                {
+                        // if something went wrong, the error message is at the top of the stack
+                        STACK_MID( L, 1);                                  // error_msg
+                        return 1;
+                }
 
                 // to see VM name in Decoda debugger
                 lua_pushliteral( K, "Keeper #");                                                  // "Keeper #"
@@ -678,11 +698,8 @@ char const* init_keepers( lua_State* L)
                 MUTEX_RECURSIVE_INIT( &GKeepers[i].lock_);
                 GKeepers[i].L = K;
         }
-#if HAVE_KEEPER_ATEXIT_DESINIT
-        atexit( atexit_close_keepers);
-#endif // HAVE_KEEPER_ATEXIT_DESINIT
         STACK_END( L, 0);
-        return NULL; // ok
+        return 0; // success
 }
 
 struct s_Keeper* keeper_acquire( unsigned long magic_)
diff --git a/src/keeper.h b/src/keeper.h
index ed11ec4..5a52f3b 100644
--- a/src/keeper.h
+++ b/src/keeper.h
@@ -8,15 +8,8 @@ struct s_Keeper
         //int count;
 };
 
-// if enabled, call close_keepers at the very last as we want to be sure no thread is GCing after.
-// (and therefore may perform linda object dereferencing after keepers are gone)
-// problem: maybe on some platforms (linux) atexit() is called after DLL/so are unloaded...
-#define HAVE_KEEPER_ATEXIT_DESINIT 0
-
-char const* init_keepers( lua_State* L);
-#if !HAVE_KEEPER_ATEXIT_DESINIT
-void close_keepers( void);
-#endif // HAVE_KEEPER_ATEXIT_DESINIT
+int init_keepers( lua_State* L);
+void close_keepers( lua_State* L);
 
 struct s_Keeper *keeper_acquire( unsigned long magic_);
 #define KEEPER_MAGIC_SHIFT 3
diff --git a/src/lanes.c b/src/lanes.c
index 71a9000..76722fe 100644
--- a/src/lanes.c
+++ b/src/lanes.c
@@ -52,7 +52,7 @@
  *      ...
  */
 
-char const* VERSION = "3.9.0";
+char const* VERSION = "3.9.1";
 
 /*
 ===============================================================================
@@ -1679,9 +1679,7 @@ static int selfdestruct_gc( lua_State* L)
                         DEBUGSPEW_CODE( fprintf( stderr, "Killed %d lane(s) at process end.\n", n));
                 }
         }
-#if !HAVE_KEEPER_ATEXIT_DESINIT
-        close_keepers();
-#endif // !HAVE_KEEPER_ATEXIT_DESINIT
+        close_keepers( L);
 
         // remove the protected allocator, if any
         {
@@ -2186,7 +2184,8 @@ LUAG_FUNC( thread_new)
         // package
         if( package != 0)
         {
-                luaG_inter_copy_package( L, L2, package, eLM_LaneBody);
+                // when copying with mode eLM_LaneBody, should raise an error in case of problem, not leave it one the stack
+                (void) luaG_inter_copy_package( L, L2, package, eLM_LaneBody);
         }
 
         // modules to require in the target lane *before* the function is transfered!
@@ -2916,10 +2915,11 @@ static const struct luaL_Reg lanes_functions [] = {
 
 
 /*
-** One-time initializations
+ * One-time initializations
  * settings table it at position 1 on the stack
-*/
-static void init_once_LOCKED( lua_State* L)
+ * pushes an error string on the stack in case of problem
+ */
+static int init_once_LOCKED( lua_State* L)
 {
         initialize_on_state_create( L);
 
@@ -2988,10 +2988,11 @@ static void init_once_LOCKED( lua_State* L)
 #endif // LINUX_SCHED_RR
 #endif // PLATFORM_LINUX
         {
-                char const* err = init_keepers( L);
-                if (err)
+                // returns non-0 if an error message was pushed on the stack
+                int pushed_error = init_keepers( L);
+                if( pushed_error)
                 {
-                        (void) luaL_error( L, "Unable to initialize: %s", err );
+                        return pushed_error;
                 }
         }
 
@@ -3030,11 +3031,12 @@ static void init_once_LOCKED( lua_State* L)
         lua_insert( L, -2); // Swap key with the Linda object
         lua_rawset( L, LUA_REGISTRYINDEX);
 
-        // we'll need this everytime we transfer some C function from/to this state
+        // we'll need this every time we transfer some C function from/to this state
         lua_newtable( L);
         lua_setfield( L, LUA_REGISTRYINDEX, LOOKUP_REGKEY);
 
         STACK_END( L, 0);
+        return 0;
 }
 
 static volatile long s_initCount = 0;
@@ -3044,6 +3046,8 @@ static volatile long s_initCount = 0;
 // param 1: settings table
 LUAG_FUNC( configure)
 {
+        // set to 1 if an error occured inside init_once_LOCKED(), and message is found at the top of the stack
+        int init_once_error = 0;
         char const* name = luaL_checkstring( L, lua_upvalueindex( 1));
         _ASSERT_L( L, lua_type( L, 1) == LUA_TTABLE);
         STACK_CHECK( L);
@@ -3081,7 +3085,7 @@ LUAG_FUNC( configure)
                 static volatile int /*bool*/ go_ahead; // = 0
                 if( InterlockedCompareExchange( &s_initCount, 1, 0) == 0)
                 {
-                        init_once_LOCKED( L);
+                        init_once_error = init_once_LOCKED( L);
                         go_ahead = 1; // let others pass
                 }
                 else
@@ -3099,7 +3103,7 @@ LUAG_FUNC( configure)
                         //
                         if( s_initCount == 0)
                         {
-                                init_once_LOCKED( L);
+                                init_once_error = init_once_LOCKED( L);
                                 s_initCount = 1;
                         }
                 }
@@ -3107,6 +3111,15 @@ LUAG_FUNC( configure)
         }
 #endif // THREADAPI == THREADAPI_PTHREAD
 
+        // raise error outside the init-once mutex
+        if( init_once_error)
+        {
+                // will raise an error if the error is not a string (should not happen)
+                char const* error = luaL_checkstring( L, -1);
+                // raises an error with the message found at the top of the stack
+                lua_error( L);
+        }
+
         // Retrieve main module interface table
         lua_pushvalue( L, lua_upvalueindex( 2));                                  // settings M
         // remove configure() (this function) from the module interface
diff --git a/src/tools.c b/src/tools.c
index 2aa9b82..d149f9b 100644
--- a/src/tools.c
+++ b/src/tools.c
@@ -591,7 +591,7 @@ void populate_func_lookup_table( lua_State* L, int _i, char const* name_)
         DEBUGSPEW_CODE( -- debugspew_indent_depth);
 }
 
-void call_on_state_create( lua_State* L, lua_State* from_, enum eLookupMode mode_)
+int call_on_state_create( lua_State* L, lua_State* from_, enum eLookupMode mode_)
 {
         if( s_on_state_create_func != NULL)
         {
@@ -607,7 +607,8 @@ void call_on_state_create( lua_State* L, lua_State* from_, enum eLookupMode mode
                         if( mode_ != eLM_LaneBody)
                         {
                                 // if attempting to call in a keeper state, do nothing because the function doesn't exist there
-                                return;
+                                // this doesn't count as an error though
+                                return 0;
                         }
                         lua_getfield( L, LUA_REGISTRYINDEX, CONFIG_REGKEY);
                         lua_getfield( L, -1, "on_state_create");
@@ -616,10 +617,12 @@ void call_on_state_create( lua_State* L, lua_State* from_, enum eLookupMode mode
                 // capture error and forward it to main state
                 if( lua_pcall( L, 0, 0, 0) != LUA_OK)
                 {
-                        (void) luaL_error( from_, "on_state_create failed: \"%s\"", lua_isstring( L, -1) ? lua_tostring( L, -1) : lua_typename( L, lua_type( L, -1)));
+                        lua_pushfstring( from_, "on_state_create failed: \"%s\"", lua_isstring( L, -1) ? lua_tostring( L, -1) : lua_typename( L, lua_type( L, -1)));
+                        return 1;
                 }
                 STACK_END( L, 0);
         }
+        return 0;
 }
 
 /* 
@@ -637,7 +640,7 @@ void call_on_state_create( lua_State* L, lua_State* from_, enum eLookupMode mode
  */
 lua_State* luaG_newstate( lua_State* from_, char const* libs_)
 {
-        // reuse alloc function from the originating state
+        // re-use alloc function from the originating state
 #if PROPAGATE_ALLOCF
         PROPAGATE_ALLOCF_PREP( from_);
 #endif // PROPAGATE_ALLOCF
@@ -648,7 +651,7 @@ lua_State* luaG_newstate( lua_State* from_, char const* libs_)
                 (void) luaL_error( from_, "luaG_newstate() failed while creating state; out of memory");
         }
 
-        // we'll need this everytime we transfer some C function from/to this state
+        // we'll need this every time we transfer some C function from/to this state
         lua_newtable( L);
         lua_setfield( L, LUA_REGISTRYINDEX, LOOKUP_REGKEY);
 
@@ -720,7 +723,11 @@ lua_State* luaG_newstate( lua_State* from_, char const* libs_)
         lua_gc( L, LUA_GCRESTART, 0);
 
         // call this after the base libraries are loaded and GC is restarted
-        call_on_state_create( L, from_, eLM_LaneBody);
+        if( call_on_state_create( L, from_, eLM_LaneBody))
+        {
+                // if something went wrong, the error message is pushed on the stack
+                lua_error( from_);
+        }
 
         STACK_CHECK( L);
         // after all this, register everything we find in our name<->function database
@@ -2158,17 +2165,20 @@ int luaG_inter_move( lua_State* L, lua_State* L2, uint_t n, enum eLookupMode mod
         return ret;
 }
 
-void luaG_inter_copy_package( lua_State* L, lua_State* L2, int _idx, enum eLookupMode mode_)
+int luaG_inter_copy_package( lua_State* L, lua_State* L2, int package_idx_, enum eLookupMode mode_)
 {
         DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "luaG_inter_copy_package()\n" INDENT_END));
         DEBUGSPEW_CODE( ++ debugspew_indent_depth);
         // package
         STACK_CHECK( L);
         STACK_CHECK( L2);
-        _idx = lua_absindex( L, _idx);
-        if( lua_type( L, _idx) != LUA_TTABLE)
+        package_idx_ = lua_absindex( L, package_idx_);
+        if( lua_type( L, package_idx_) != LUA_TTABLE)
         {
-                (void) luaL_error( L, "expected package as table, got %s", luaL_typename( L, _idx));
+                lua_pushfstring( L, "expected package as table, got %s", luaL_typename( L, package_idx_));
+                STACK_MID( L, 1);
+                // raise the error when copying from lane to lane, else just leave it on the stack to be raised later
+                return ( mode_ == eLM_LaneBody) ? lua_error( L) : 1;
         }
         lua_getglobal( L2, "package");
         if( !lua_isnil( L2, -1)) // package library not loaded: do nothing
@@ -2182,7 +2192,7 @@ void luaG_inter_copy_package( lua_State* L, lua_State* L2, int _idx, enum eLooku
                 for( i = 0; entries[i]; ++ i)
                 {
                         DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "%s\n" INDENT_END, entries[i]));
-                        lua_getfield( L, _idx, entries[i]);
+                        lua_getfield( L, package_idx_, entries[i]);
                         if( lua_isnil( L, -1))
                         {
                                 lua_pop( L, 1);
@@ -2204,6 +2214,7 @@ void luaG_inter_copy_package( lua_State* L, lua_State* L2, int _idx, enum eLooku
         STACK_END( L2, 0);
         STACK_END( L, 0);
         DEBUGSPEW_CODE( -- debugspew_indent_depth);
+        return 0;
 }
 
 
diff --git a/src/tools.h b/src/tools.h
index ebe407b..5bd4b69 100644
--- a/src/tools.h
+++ b/src/tools.h
@@ -118,7 +118,7 @@ enum eLookupMode
 };
 
 char const* push_deep_proxy( lua_State* L, DEEP_PRELUDE* prelude, enum eLookupMode mode_);
-void luaG_inter_copy_package( lua_State* L, lua_State* L2, int _idx, enum eLookupMode mode_);
+int luaG_inter_copy_package( lua_State* L, lua_State* L2, int package_idx_, enum eLookupMode mode_);
 
 int luaG_inter_copy( lua_State *L, lua_State *L2, uint_t n, enum eLookupMode mode_);
 int luaG_inter_move( lua_State *L, lua_State *L2, uint_t n, enum eLookupMode mode_);
@@ -134,7 +134,7 @@ extern MUTEX_T mtid_lock;
 void populate_func_lookup_table( lua_State* L, int _i, char const* _name);
 void serialize_require( lua_State *L);
 int initialize_on_state_create( lua_State *L);
-void call_on_state_create( lua_State* L, lua_State* from_, enum eLookupMode mode_);
+int call_on_state_create( lua_State* L, lua_State* from_, enum eLookupMode mode_);
 
 extern MUTEX_T require_cs;