Merge branch 'sverker/ets-cherries/OTP-15031'

* sverker/ets-cherries/OTP-15031:
  erts: Use table ref for select continuation
  erts: Refactor erl_db_hash next() into next_live()
  erts: Change wrong alloc_fnf

4 files changed, 76 insertions, 30 deletions

diff --git a/erts/emulator/beam/erl_db.c b/erts/emulator/beam/erl_db.c
index a76d769283..f7ee408991 100644
--- a/erts/emulator/beam/erl_db.c
+++ b/erts/emulator/beam/erl_db.c
@@ -283,6 +283,13 @@ make_tid(Process *c_p, DbTable *tb)
     return erts_mk_magic_ref(&hp, &c_p->off_heap, tb->common.btid);
 }
 
+Eterm
+erts_db_make_tid(Process *c_p, DbTableCommon *tb)
+{
+    return make_tid(c_p, (DbTable*)tb);
+}
+
+
 
 /* 
 ** The meta hash table of all NAMED ets tables
diff --git a/erts/emulator/beam/erl_db.h b/erts/emulator/beam/erl_db.h
index 318e90cb28..eb6da2c9fb 100644
--- a/erts/emulator/beam/erl_db.h
+++ b/erts/emulator/beam/erl_db.h
@@ -128,6 +128,7 @@ extern erts_atomic_t erts_ets_misc_mem_size;
 
 Eterm erts_ets_colliding_names(Process*, Eterm name, Uint cnt);
 Uint erts_db_get_max_tabs(void);
+Eterm erts_db_make_tid(Process *c_p, DbTableCommon *tb);
 
 #ifdef ERTS_ENABLE_LOCK_COUNT
 void erts_lcnt_enable_db_lock_count(DbTable *tb, int enable);
diff --git a/erts/emulator/beam/erl_db_hash.c b/erts/emulator/beam/erl_db_hash.c
index 5d49b2ea14..cb5c496e90 100644
--- a/erts/emulator/beam/erl_db_hash.c
+++ b/erts/emulator/beam/erl_db_hash.c
@@ -340,8 +340,8 @@ typedef int (*extra_match_validator_t)(int keypos, Eterm match, Eterm guard, Ete
 static struct ext_segtab* alloc_ext_segtab(DbTableHash* tb, unsigned seg_ix);
 static void alloc_seg(DbTableHash *tb);
 static int free_seg(DbTableHash *tb, int free_records);
-static HashDbTerm* next(DbTableHash *tb, Uint *iptr, erts_rwmtx_t** lck_ptr,
-			HashDbTerm *list);
+static HashDbTerm* next_live(DbTableHash *tb, Uint *iptr, erts_rwmtx_t** lck_ptr,
+			     HashDbTerm *list);
 static HashDbTerm* search_list(DbTableHash* tb, Eterm key, 
 			       HashValue hval, HashDbTerm *list);
 static void shrink(DbTableHash* tb, int nitems);
@@ -646,9 +646,9 @@ int db_create_hash(Process *p, DbTable *tbl)
 	    rwmtx_opt.type = ERTS_RWMTX_TYPE_FREQUENT_READ;
 	if (erts_ets_rwmtx_spin_count >= 0)
 	    rwmtx_opt.main_spincount = erts_ets_rwmtx_spin_count;
-	tb->locks = (DbTableHashFineLocks*) erts_db_alloc_fnf(ERTS_ALC_T_DB_SEG, /* Other type maybe? */ 
-							      (DbTable *) tb,
-							      sizeof(DbTableHashFineLocks));	    	    
+	tb->locks = (DbTableHashFineLocks*) erts_db_alloc(ERTS_ALC_T_DB_SEG, /* Other type maybe? */
+                                                          (DbTable *) tb,
+                                                          sizeof(DbTableHashFineLocks));
 	for (i=0; i<DB_HASH_LOCK_CNT; ++i) {
             erts_rwmtx_init_opt(&tb->locks->lck_vec[i].lck, &rwmtx_opt,
                 "db_hash_slot", tb->common.the_name, ERTS_LOCK_FLAGS_CATEGORY_DB);
@@ -672,19 +672,9 @@ static int db_first_hash(Process *p, DbTable *tbl, Eterm *ret)
     erts_rwmtx_t* lck = RLOCK_HASH(tb,ix);
     HashDbTerm* list;
 
-    for (;;) {
-	list = BUCKET(tb,ix);
-	if (list != NULL) {
-	    if (list->hvalue == INVALID_HASH) {
-		list = next(tb,&ix,&lck,list);
-	    }
-	    break;
-	}
-	if ((ix=next_slot(tb,ix,&lck)) == 0) {
-	    list = NULL;
-	    break;
-	}
-    }
+    list = BUCKET(tb,ix);
+    list = next_live(tb, &ix, &lck, list);
+
     if (list != NULL) {
 	*ret = db_copy_key(p, tbl, &list->dbterm);
 	RUNLOCK_HASH(lck);
@@ -721,13 +711,13 @@ static int db_next_hash(Process *p, DbTable *tbl, Eterm key, Eterm *ret)
     }
     /* Key found */
 
-    b = next(tb, &ix, &lck, b);
+    b = next_live(tb, &ix, &lck, b->next);
     if (tb->common.status & (DB_BAG | DB_DUPLICATE_BAG)) {
 	while (b != 0) {
 	    if (!has_live_key(tb, b, key, hval)) {
 		break;
 	    }
-	    b = next(tb, &ix, &lck, b);
+	    b = next_live(tb, &ix, &lck, b->next);
 	}
     }
     if (b == NULL) {
@@ -1463,20 +1453,24 @@ static ERTS_INLINE int on_mtraversal_simple_trap(Export* trap_function,
 
     BUMP_ALL_REDS(p);
     if (IS_USMALL(0, got)) {
-	hp = HAlloc(p,  base_halloc_sz + 5);
+	hp = HAllocX(p,  base_halloc_sz + 5, ERTS_MAGIC_REF_THING_SIZE);
 	egot = make_small(got);
     }
     else {
-	hp = HAlloc(p, base_halloc_sz + BIG_UINT_HEAP_SIZE + 5);
+	hp = HAllocX(p, base_halloc_sz + BIG_UINT_HEAP_SIZE + 5,
+                     ERTS_MAGIC_REF_THING_SIZE);
 	egot = uint_to_big(got, hp);
 	hp += BIG_UINT_HEAP_SIZE;
     }
 
     if (is_first_trap) {
+        if (is_atom(tid))
+            tid = erts_db_make_tid(p, &tb->common);
         mpb = erts_db_make_match_prog_ref(p, *mpp, &hp);
         *mpp = NULL; /* otherwise the caller will destroy it */
     }
     else {
+        ASSERT(!is_atom(tid));
         mpb = prev_continuation_tptr[3];
     }
 
@@ -1590,11 +1584,17 @@ static int mtraversal_select_chunk_on_loop_ended(void* context_ptr, Sint slot_ix
                                              been in 'user space' */
             }
             if (rest != NIL || slot_ix >= 0) { /* Need more calls */
-                sc_context_ptr->hp = HAlloc(sc_context_ptr->p, 3 + 7 + ERTS_MAGIC_REF_THING_SIZE);
+                Eterm tid = sc_context_ptr->tid;
+                sc_context_ptr->hp = HAllocX(sc_context_ptr->p,
+                                             3 + 7 + ERTS_MAGIC_REF_THING_SIZE,
+                                             ERTS_MAGIC_REF_THING_SIZE);
                 mpb = erts_db_make_match_prog_ref(sc_context_ptr->p, *mpp, &sc_context_ptr->hp);
+                if (is_atom(tid))
+                    tid = erts_db_make_tid(sc_context_ptr->p,
+                                           &sc_context_ptr->tb->common);
                 continuation = TUPLE6(
                         sc_context_ptr->hp,
-                        sc_context_ptr->tid,
+                        tid,
                         make_small(slot_ix),
                         make_small(sc_context_ptr->chunk_size),
                         mpb, rest,
@@ -1631,12 +1631,16 @@ static int mtraversal_select_chunk_on_trap(void* context_ptr, Sint slot_ix, Sint
     BUMP_ALL_REDS(sc_context_ptr->p);
 
     if (sc_context_ptr->prev_continuation_tptr == NULL) {
+        Eterm tid = sc_context_ptr->tid;
         /* First time we're trapping */
-        hp = HAlloc(sc_context_ptr->p, 7 + ERTS_MAGIC_REF_THING_SIZE);
+        hp = HAllocX(sc_context_ptr->p, 7 + ERTS_MAGIC_REF_THING_SIZE,
+                     ERTS_MAGIC_REF_THING_SIZE);
+        if (is_atom(tid))
+            tid = erts_db_make_tid(sc_context_ptr->p, &sc_context_ptr->tb->common);
         mpb = erts_db_make_match_prog_ref(sc_context_ptr->p, *mpp, &hp);
         continuation = TUPLE6(
                 hp,
-                sc_context_ptr->tid,
+                tid,
                 make_small(slot_ix),
                 make_small(sc_context_ptr->chunk_size),
                 mpb,
@@ -2905,14 +2909,14 @@ static HashDbTerm* search_list(DbTableHash* tb, Eterm key,
 /* It return the next live object in a table, NULL if no more */
 /* In-bucket: RLOCKED */
 /* Out-bucket: RLOCKED unless NULL */
-static HashDbTerm* next(DbTableHash *tb, Uint *iptr, erts_rwmtx_t** lck_ptr,
-			HashDbTerm *list)
+static HashDbTerm* next_live(DbTableHash *tb, Uint *iptr, erts_rwmtx_t** lck_ptr,
+			     HashDbTerm *list)
 {
     int i;
 
     ERTS_LC_ASSERT(IS_HASH_RLOCKED(tb,*iptr));
 
-    for (list = list->next; list != NULL; list = list->next) {
+    for ( ; list != NULL; list = list->next) {
 	if (list->hvalue != INVALID_HASH)
 	    return list;        
     }
diff --git a/lib/stdlib/test/ets_SUITE.erl b/lib/stdlib/test/ets_SUITE.erl
index ec4a16b510..02211fa8df 100644
--- a/lib/stdlib/test/ets_SUITE.erl
+++ b/lib/stdlib/test/ets_SUITE.erl
@@ -55,6 +55,7 @@
 -export([t_repair_continuation/1]).
 -export([t_match_spec_run/1]).
 -export([t_bucket_disappears/1]).
+-export([t_named_select/1]).
 -export([otp_5340/1]).
 -export([otp_6338/1]).
 -export([otp_6842_select_1000/1]).
@@ -124,6 +125,7 @@ all() ->
      t_init_table, t_whitebox, t_delete_all_objects,
      t_insert_list, t_test_ms, t_select_delete, t_select_replace,
      t_ets_dets, memory, t_select_reverse, t_bucket_disappears,
+     t_named_select,
      select_fail, t_insert_new, t_repair_continuation,
      otp_5340, otp_6338, otp_6842_select_1000, otp_7665,
      otp_8732, meta_wb, grow_shrink, grow_pseudo_deleted,
@@ -205,6 +207,38 @@ t_bucket_disappears_do(Opts) ->
     true = ets:delete(abcd),
     verify_etsmem(EtsMem).
 
+%% OTP-21: Test that select/1 fails if named table was deleted and recreated
+%%         and succeeds if table was renamed.
+t_named_select(_Config) ->
+    repeat_for_opts(fun t_named_select_do/1).
+
+t_named_select_do(Opts) ->
+    EtsMem = etsmem(),
+    T = t_name_tid_select,
+    ets_new(T, [named_table | Opts]),
+    ets:insert(T, {1,11}),
+    ets:insert(T, {2,22}),
+    ets:insert(T, {3,33}),
+    MS = [{{'$1', 22}, [], ['$1']}],
+    {[2], Cont1} = ets:select(T, MS, 1),
+    ets:delete(T),
+    {'EXIT',{badarg,_}} = (catch ets:select(Cont1)),
+    ets_new(T, [named_table | Opts]),
+    {'EXIT',{badarg,_}} = (catch ets:select(Cont1)),
+
+    true = ets:insert_new(T, {1,22}),
+    true = ets:insert_new(T, {2,22}),
+    true = ets:insert_new(T, {4,22}),
+    {[A,B], Cont2} = ets:select(T, MS, 2),
+    ets:rename(T, abcd),
+    {[C], '$end_of_table'} = ets:select(Cont2),
+    7 = A + B + C,
+
+    true = ets:delete(abcd),
+    verify_etsmem(EtsMem).
+
+
+
 
 %% Check ets:match_spec_run/2.
 t_match_spec_run(Config) when is_list(Config) ->
@@ -700,7 +734,7 @@ whitebox_2(Opts) ->
     ets:delete(T2),
     ok.
 
-select_bound_chunk(Config) ->
+select_bound_chunk(_Config) ->
     repeat_for_opts(fun select_bound_chunk_do/1, [all_types]).
 
 select_bound_chunk_do(Opts) ->