fixed a shutdown crash

* fixed a crash that can occur at shutdown when an object stored inside
a keeper state performs a linda operation on a linda making use of
another keeper
* bumped version to 3.7.5

2 files changed, 26 insertions, 15 deletions

diff --git a/src/keeper.c b/src/keeper.c
index 99f510b..4c90069 100644
--- a/src/keeper.c
+++ b/src/keeper.c
@@ -184,7 +184,8 @@ static void push_table( lua_State* L, int idx)
 int keeper_push_linda_storage( lua_State* L, void* ptr)
 {
         struct s_Keeper* K = keeper_acquire( ptr);
-        lua_State* KL = K->L;
+        lua_State* KL = K ? K->L : NULL;
+        if( KL == NULL) return 0;
         STACK_CHECK( KL);
         lua_pushlightuserdata( KL, fifos_key);                      // fifos_key
         lua_rawget( KL, LUA_REGISTRYINDEX);                         // fifos
@@ -535,14 +536,18 @@ void close_keepers( void)
 #endif // HAVE_KEEPER_ATEXIT_DESINIT
 {
         int i;
-        // 2-pass close, in case a keeper holds a reference to a linda bound to another keeoer
-        for( i = 0; i < GNbKeepers; ++ i)
+        int const nbKeepers = GNbKeepers;
+        // NOTE: imagine some keeper state N+1 currently holds a linda that uses another keeper N, and a _gc that will make use of it
+        // when keeper N+1 is closed, object is GCed, linda operation is called, which attempts to acquire keeper N, whose Lua state no longer exists
+        // in that case, the linda operation should do nothing. which means that these operations must check for keeper acquisition success
+        GNbKeepers = 0;
+        for( i = 0; i < nbKeepers; ++ i)
         {
                 lua_State* L = GKeepers[i].L;
                 GKeepers[i].L = NULL;
                 lua_close( L);
         }
-        for( i = 0; i < GNbKeepers; ++ i)
+        for( i = 0; i < nbKeepers; ++ i)
         {
                 MUTEX_FREE( &GKeepers[i].lock_);
         }
@@ -551,7 +556,6 @@ void close_keepers( void)
                 free( GKeepers);
         }
         GKeepers = NULL;
-        GNbKeepers = 0;
 }
 
 /*
@@ -626,7 +630,7 @@ struct s_Keeper* keeper_acquire( void const* ptr)
                 * have to cast to unsigned long to avoid compilation warnings about loss of data when converting pointer-to-integer
                 */
                 unsigned int i = (unsigned int)(((unsigned long)(ptr) >> 3) % GNbKeepers);
-                struct s_Keeper *K= &GKeepers[i];
+                struct s_Keeper* K= &GKeepers[i];
 
                 MUTEX_LOCK( &K->lock_);
                 //++ K->count;
diff --git a/src/lanes.c b/src/lanes.c
index 6621735..e66342d 100644
--- a/src/lanes.c
+++ b/src/lanes.c
@@ -52,7 +52,7 @@
  *      ...
  */
 
-char const* VERSION = "3.7.4";
+char const* VERSION = "3.7.5";
 
 /*
 ===============================================================================
@@ -420,7 +420,8 @@ LUAG_FUNC( linda_send)
         STACK_GROW(L, 1);
         {
                 struct s_Keeper* K = keeper_acquire( linda);
-                lua_State* KL = K->L;    // need to do this for 'STACK_CHECK'
+                lua_State* KL = K ? K->L : NULL; // need to do this for 'STACK_CHECK'
+                if( KL == NULL) return 0;
                 STACK_CHECK( KL);
                 for( ;;)
                 {
@@ -584,6 +585,7 @@ LUAG_FUNC( linda_receive)
 
         {
                 struct s_Keeper *K = keeper_acquire( linda);
+                if( K == NULL) return 0;
                 for( ;;)
                 {
                         // all arguments of receive() but the first are passed to the keeper's receive function
@@ -690,6 +692,7 @@ LUAG_FUNC( linda_set)
         {
                 int pushed;
                 struct s_Keeper *K = keeper_acquire( linda);
+                if( K == NULL) return 0;
                 // no nil->sentinel toggling, we really clear the linda contents for the given key with a set()
                 pushed = keeper_call( K->L, KEEPER_API( set), L, linda, 2);
                 if( pushed >= 0) // no error?
@@ -722,7 +725,7 @@ LUAG_FUNC( linda_set)
  */
 LUAG_FUNC( linda_count)
 {
-        struct s_Linda *linda= lua_toLinda( L, 1);
+        struct s_Linda* linda = lua_toLinda( L, 1);
         int pushed;
 
         luaL_argcheck( L, linda, 1, "expected a linda object!");
@@ -730,7 +733,8 @@ LUAG_FUNC( linda_count)
         check_key_types( L, 2, lua_gettop( L));
 
         {
-                struct s_Keeper *K = keeper_acquire( linda);
+                struct s_Keeper* K = keeper_acquire( linda);
+                if( K == NULL) return 0;
                 pushed = keeper_call( K->L, KEEPER_API( count), L, linda, 2);
                 keeper_release( K);
                 if( pushed < 0)
@@ -758,14 +762,15 @@ LUAG_FUNC( linda_get)
         check_key_types( L, 2, 2);
 
         {
-                struct s_Keeper *K = keeper_acquire( linda);
+                struct s_Keeper* K = keeper_acquire( linda);
+                if( K == NULL) return 0;
                 pushed = keeper_call( K->L, KEEPER_API( get), L, linda, 2);
-                ASSERT_L( pushed==0 || pushed==1 );
+                ASSERT_L( pushed == 0 || pushed == 1);
                 if( pushed > 0)
                 {
                         keeper_toggle_nil_sentinels( L, lua_gettop( L) - pushed, 0);
                 }
-                keeper_release(K);
+                keeper_release( K);
                 // must trigger error after keeper state has been released
                 if( pushed < 0)
                 {
@@ -784,7 +789,8 @@ LUAG_FUNC( linda_get)
 */
 LUAG_FUNC( linda_limit)
 {
-        struct s_Linda* linda= lua_toLinda( L, 1 );
+        struct s_Linda* linda= lua_toLinda( L, 1);
+        int pushed;
 
         luaL_argcheck( L, linda, 1, "expected a linda object!");
         // make sure we got a key and a limit
@@ -796,7 +802,8 @@ LUAG_FUNC( linda_limit)
 
         {
                 struct s_Keeper* K = keeper_acquire( linda);
-                int pushed = keeper_call( K->L, KEEPER_API( limit), L, linda, 2);
+                if( K == NULL) return 0;
+                pushed = keeper_call( K->L, KEEPER_API( limit), L, linda, 2);
                 ASSERT_L( pushed <= 0); // either error or no return values
                 keeper_release( K);
                 // must trigger error after keeper state has been released