Merge branch 'sverk/fix-alloc-fixes' into maint

* sverk/fix-alloc-fixes:
  erts: Remove unnecessary utf8 analysis step in external decoding
  erts: Fix locking order violation for allocation wrappers
  erts: Change locking order for "port_table" and "port_sched_lock"
  erts: Adjust sizes for fix allocator
  erts: Fix unabused bug in fixed allocation
  erts: Fix benign size-bug for fix-allocators MONITOR_SH and NLINK_SH
  erts: Refactor in new struct ErtsAllctrFixDDBlock_t

OTP-11085

7 files changed, 274 insertions, 84 deletions

diff --git a/erts/emulator/beam/erl_alloc.c b/erts/emulator/beam/erl_alloc.c
index d748f86d75..c19a2647e4 100644
--- a/erts/emulator/beam/erl_alloc.c
+++ b/erts/emulator/beam/erl_alloc.c
@@ -495,6 +495,38 @@ refuse_af_strategy(struct au_init *init)
 static void hdbg_init(void);
 #endif
 
+static void adjust_fix_alloc_sizes(UWord extra_block_size)
+{
+    
+    if (extra_block_size && erts_allctrs_info[ERTS_ALC_A_FIXED_SIZE].enabled) {
+	int j;
+
+#ifdef ERTS_SMP
+	if (erts_allctrs_info[ERTS_ALC_A_FIXED_SIZE].thr_spec) {
+	    int i;
+	    ErtsAllocatorThrSpec_t* tspec;
+
+	    tspec = &erts_allctr_thr_spec[ERTS_ALC_A_FIXED_SIZE];	
+	    ASSERT(tspec->enabled);
+
+	    for (i=0; i < tspec->size; i++) {
+		Allctr_t* allctr = tspec->allctr[i];
+		for (j=0; j < ERTS_ALC_NO_FIXED_SIZES; ++j) {
+		    allctr->fix[j].type_size += extra_block_size;
+		}
+	    }
+	}
+	else
+#endif
+	{
+	    Allctr_t* allctr = erts_allctrs_info[ERTS_ALC_A_FIXED_SIZE].extra;
+	    for (j=0; j < ERTS_ALC_NO_FIXED_SIZES; ++j) {
+		allctr->fix[j].type_size += extra_block_size;
+	    }	
+	}
+    }
+}
+
 void
 erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
 {
@@ -515,9 +547,9 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
 	= sizeof(Process);
 #if !HALFWORD_HEAP
     fix_type_sizes[ERTS_ALC_FIX_TYPE_IX(ERTS_ALC_T_MONITOR_SH)]
-	= ERTS_MONITOR_SH_SIZE;
+	= ERTS_MONITOR_SH_SIZE * sizeof(Uint);
     fix_type_sizes[ERTS_ALC_FIX_TYPE_IX(ERTS_ALC_T_NLINK_SH)]
-	= ERTS_LINK_SH_SIZE;
+	= ERTS_LINK_SH_SIZE * sizeof(Uint);
 #endif
     fix_type_sizes[ERTS_ALC_FIX_TYPE_IX(ERTS_ALC_T_DRV_EV_D_STATE)]
 	= sizeof(ErtsDrvEventDataState);
@@ -538,6 +570,8 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
     if (ncpu < 1)
 	ncpu = 1;
 
+    erts_tsd_key_create(&erts_allctr_prelock_tsd_key);
+
     erts_sys_alloc_init();
     erts_init_utils_mem();
 
@@ -768,7 +802,7 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
 #ifdef DEBUG
     extra_block_size += install_debug_functions();
 #endif
-
+    adjust_fix_alloc_sizes(extra_block_size);
 }
 
 void
@@ -3107,6 +3141,55 @@ erts_request_alloc_info(struct process *c_p,
     return 1;
 }
 
+/* 
+ * The allocator wrapper prelocking stuff below is about the locking order.
+ * It only affects wrappers (erl_mtrace.c and erl_instrument.c) that keep locks
+ * during alloc/realloc/free.
+ *
+ * Some query functions in erl_alloc_util.c lock the allocator mutex and then
+ * use erts_printf that in turn may call the sys allocator through the wrappers.
+ * To avoid breaking locking order these query functions first "pre-locks" all
+ * allocator wrappers.
+ */
+ErtsAllocatorWrapper_t *erts_allctr_wrappers;
+int erts_allctr_wrapper_prelocked = 0;
+erts_tsd_key_t erts_allctr_prelock_tsd_key;
+
+void erts_allctr_wrapper_prelock_init(ErtsAllocatorWrapper_t* wrapper)
+{
+    ASSERT(wrapper->lock && wrapper->unlock);
+    wrapper->next = erts_allctr_wrappers;
+    erts_allctr_wrappers = wrapper;
+}
+
+void erts_allctr_wrapper_pre_lock(void)
+{
+    if (erts_allctr_wrappers) {
+	ErtsAllocatorWrapper_t* wrapper = erts_allctr_wrappers;
+	for ( ; wrapper; wrapper = wrapper->next) {
+	    wrapper->lock();
+	}
+	ASSERT(!erts_allctr_wrapper_prelocked);
+	erts_allctr_wrapper_prelocked = 1;
+	erts_tsd_set(erts_allctr_prelock_tsd_key, (void*)1);
+    }
+}
+
+void erts_allctr_wrapper_pre_unlock(void)
+{
+    if (erts_allctr_wrappers) {
+	ErtsAllocatorWrapper_t* wrapper = erts_allctr_wrappers;
+	
+	erts_allctr_wrapper_prelocked = 0;
+	erts_tsd_set(erts_allctr_prelock_tsd_key, (void*)0);
+	for ( ; wrapper; wrapper = wrapper->next) {
+	    wrapper->unlock();
+	}
+    }
+}
+
+
+
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
  * Deprecated functions                                                    *
  *                                                                         *
diff --git a/erts/emulator/beam/erl_alloc.h b/erts/emulator/beam/erl_alloc.h
index ba5ec9c367..9cafd8ddc8 100644
--- a/erts/emulator/beam/erl_alloc.h
+++ b/erts/emulator/beam/erl_alloc.h
@@ -135,6 +135,18 @@ typedef struct {
 
 extern ErtsAllocatorThrSpec_t erts_allctr_thr_spec[ERTS_ALC_A_MAX+1];
 
+typedef struct ErtsAllocatorWrapper_t_ {
+    void (*lock)(void);
+    void (*unlock)(void);
+    struct ErtsAllocatorWrapper_t_* next;
+}ErtsAllocatorWrapper_t;
+ErtsAllocatorWrapper_t *erts_allctr_wrappers;
+extern int erts_allctr_wrapper_prelocked;
+extern erts_tsd_key_t erts_allctr_prelock_tsd_key;
+void erts_allctr_wrapper_prelock_init(ErtsAllocatorWrapper_t* wrapper);
+void erts_allctr_wrapper_pre_lock(void);
+void erts_allctr_wrapper_pre_unlock(void);
+
 void erts_alloc_register_scheduler(void *vesdp);
 #ifdef ERTS_SMP
 void erts_alloc_scheduler_handle_delayed_dealloc(void *vesdp,
@@ -188,6 +200,7 @@ void *erts_realloc(ErtsAlcType_t type, void *ptr, Uint size);
 void erts_free(ErtsAlcType_t type, void *ptr);
 void *erts_alloc_fnf(ErtsAlcType_t type, Uint size);
 void *erts_realloc_fnf(ErtsAlcType_t type, void *ptr, Uint size);
+int erts_is_allctr_wrapper_prelocked(void);
 
 #endif /* #if !ERTS_ALC_DO_INLINE */
 
@@ -258,6 +271,13 @@ void *erts_realloc_fnf(ErtsAlcType_t type, void *ptr, Uint size)
 	size);
 }
 
+ERTS_ALC_INLINE
+int erts_is_allctr_wrapper_prelocked(void)
+{
+    return erts_allctr_wrapper_prelocked                 /* locked */
+	&& !!erts_tsd_get(erts_allctr_prelock_tsd_key);  /* by me  */
+}
+
 #endif /* #if ERTS_ALC_DO_INLINE || defined(ERTS_ALC_INTERNAL__) */
 
 #define ERTS_ALC_GET_THR_IX() ((int) erts_get_scheduler_id())
diff --git a/erts/emulator/beam/erl_alloc_util.c b/erts/emulator/beam/erl_alloc_util.c
index ac7f420708..cbeb2c1e3a 100644
--- a/erts/emulator/beam/erl_alloc_util.c
+++ b/erts/emulator/beam/erl_alloc_util.c
@@ -588,17 +588,21 @@ do {									\
 
 #ifdef DEBUG
 #ifdef USE_THREADS
+# ifdef ERTS_SMP
+#  define IS_ACTUALLY_BLOCKING (erts_thr_progress_is_blocking())
+# else
+#  define IS_ACTUALLY_BLOCKING 0
+# endif
 #define ERTS_ALCU_DBG_CHK_THR_ACCESS(A)					\
 do {									\
-    if (!(A)->thread_safe) {						\
-	if (!(A)->debug.saved_tid) {					\
+    if (!(A)->thread_safe && !IS_ACTUALLY_BLOCKING) {                   \
+	if (!(A)->debug.saved_tid) {                                    \
 	    (A)->debug.tid = erts_thr_self();				\
 	    (A)->debug.saved_tid = 1;					\
 	}								\
 	else {								\
 	    ERTS_SMP_LC_ASSERT(						\
-		ethr_equal_tids((A)->debug.tid, erts_thr_self())	\
-		|| erts_thr_progress_is_blocking());			\
+		ethr_equal_tids((A)->debug.tid, erts_thr_self()));	\
 	}								\
     }									\
 } while (0)
@@ -878,8 +882,10 @@ erts_alcu_fix_alloc_shrink(Allctr_t *allctr, erts_aint32_t flgs)
 
 #ifdef ERTS_SMP
 
-#define ERTS_ALCU_DD_FIX_TYPE_OFFS \
-  ((sizeof(ErtsAllctrDDBlock_t)-1)/sizeof(UWord) + 1)
+typedef struct {
+    ErtsAllctrDDBlock_t ddblock__; /* must be first */
+    ErtsAlcType_t fix_type;
+}ErtsAllctrFixDDBlock_t;
 
 
 static ERTS_INLINE Allctr_t*
@@ -1180,7 +1186,7 @@ handle_delayed_dealloc(Allctr_t *allctr,
 	if (fix) {
 	    ErtsAlcType_t type;
 
-	    type = (ErtsAlcType_t) ((UWord *) ptr)[ERTS_ALCU_DD_FIX_TYPE_OFFS];
+	    type = ((ErtsAllctrFixDDBlock_t*) ptr)->fix_type;
 	    ix = type - ERTS_ALC_N_MIN_A_FIXED_SIZE;
 	    ERTS_DBG_CHK_FIX_LIST(allctr, fix, ix, 1);
 	    fix[ix].used--;
@@ -1242,7 +1248,7 @@ enqueue_dealloc_other_instance(ErtsAlcType_t type,
 			       int cinit)
 {
     if (allctr->fix)
-	((UWord *) ptr)[ERTS_ALCU_DD_FIX_TYPE_OFFS] = (UWord) type;
+	((ErtsAllctrFixDDBlock_t*) ptr)->fix_type = type;
 
     if (ddq_enqueue(type, &allctr->dd.q, ptr, cinit))
 	erts_alloc_notify_delayed_dealloc(allctr->ix);
@@ -2508,12 +2514,6 @@ static erts_mtx_t init_atoms_mtx;
 static void
 init_atoms(Allctr_t *allctr)
 {
-
-#ifdef USE_THREADS
-    if (allctr && allctr->thread_safe)
-	erts_mtx_unlock(&allctr->mutex);
-#endif
-
     erts_mtx_lock(&init_atoms_mtx);
 
     if (!atoms_initialized) {
@@ -2604,18 +2604,13 @@ init_atoms(Allctr_t *allctr)
 	    fix_type_atoms[ix] = am_atom_put(name, len);
 	}
     }
-
     
-    if (allctr) {
+    if (allctr && !allctr->atoms_initialized) {
 
 	make_name_atoms(allctr);
 
 	(*allctr->init_atoms)();
 
-#ifdef USE_THREADS
-	if (allctr->thread_safe)
-	    erts_mtx_lock(&allctr->mutex);
-#endif
     	allctr->atoms_initialized = 1;
     }
 
@@ -3243,17 +3238,21 @@ erts_alcu_info_options(Allctr_t *allctr,
 {
     Eterm res;
 
+    if (hpp || szp)
+	ensure_atoms_initialized(allctr);
 
 #ifdef USE_THREADS
-    if (allctr->thread_safe)
+    if (allctr->thread_safe) {
+	erts_allctr_wrapper_pre_lock();
 	erts_mtx_lock(&allctr->mutex);
+    }
 #endif
-    if (hpp || szp)
-	ensure_atoms_initialized(allctr);
     res = info_options(allctr, print_to_p, print_to_arg, hpp, szp);
 #ifdef USE_THREADS
-    if (allctr->thread_safe)
+    if (allctr->thread_safe) { 
 	erts_mtx_unlock(&allctr->mutex);
+	erts_allctr_wrapper_pre_unlock();
+    }
 #endif
     return res;
 }
@@ -3280,16 +3279,18 @@ erts_alcu_sz_info(Allctr_t *allctr,
 	return am_false;
     }
 
+    if (hpp || szp)
+	ensure_atoms_initialized(allctr);
+
 #ifdef USE_THREADS
-    if (allctr->thread_safe)
+    if (allctr->thread_safe) {
+	erts_allctr_wrapper_pre_lock();
 	erts_mtx_lock(&allctr->mutex);
+    }
 #endif
 
     ERTS_ALCU_DBG_CHK_THR_ACCESS(allctr);
 
-    if (hpp || szp)
-	ensure_atoms_initialized(allctr);
-
     /* Update sbc values not continously updated */
     allctr->sbcs.blocks.curr.no
 	= allctr->sbcs.curr.norm.mseg.no + allctr->sbcs.curr.norm.sys_alloc.no;
@@ -3325,13 +3326,16 @@ erts_alcu_sz_info(Allctr_t *allctr,
 
 
 #ifdef USE_THREADS
-    if (allctr->thread_safe)
+    if (allctr->thread_safe) {
 	erts_mtx_unlock(&allctr->mutex);
+	erts_allctr_wrapper_pre_unlock();
+    }
 #endif
 
     return res;
 }
 
+
 Eterm
 erts_alcu_info(Allctr_t *allctr,
 	       int begin_max_period,
@@ -3352,16 +3356,18 @@ erts_alcu_info(Allctr_t *allctr,
 	return am_false;
     }
 
+    if (hpp || szp)
+	ensure_atoms_initialized(allctr);
+
 #ifdef USE_THREADS
-    if (allctr->thread_safe)
+    if (allctr->thread_safe) {
+	erts_allctr_wrapper_pre_lock();
 	erts_mtx_lock(&allctr->mutex);
+    }
 #endif
 
     ERTS_ALCU_DBG_CHK_THR_ACCESS(allctr);
 
-    if (hpp || szp)
-	ensure_atoms_initialized(allctr);
-
     /* Update sbc values not continously updated */
     allctr->sbcs.blocks.curr.no
 	= allctr->sbcs.curr.norm.mseg.no + allctr->sbcs.curr.norm.sys_alloc.no;
@@ -3414,8 +3420,10 @@ erts_alcu_info(Allctr_t *allctr,
 
 
 #ifdef USE_THREADS
-    if (allctr->thread_safe)
+    if (allctr->thread_safe) {
 	erts_mtx_unlock(&allctr->mutex);
+	erts_allctr_wrapper_pre_unlock();
+    }
 #endif
 
     return res;
@@ -3487,7 +3495,9 @@ do_erts_alcu_alloc(ErtsAlcType_t type, void *extra, Uint size)
     fix = allctr->fix;
     if (fix) {
 	int ix = type - ERTS_ALC_N_MIN_A_FIXED_SIZE;
+	ASSERT((unsigned)ix < ERTS_ALC_NO_FIXED_SIZES);
 	ERTS_DBG_CHK_FIX_LIST(allctr, fix, ix, 1);
+	ASSERT(size <= fix[ix].type_size);
 	fix[ix].used++;
 	res = fix[ix].list;
 	if (res) {
@@ -3508,8 +3518,7 @@ do_erts_alcu_alloc(ErtsAlcType_t type, void *extra, Uint size)
 	    ERTS_DBG_CHK_FIX_LIST(allctr, fix, ix, 0);
 	    return res;
 	}
-	if (size < 2*sizeof(UWord))
-	    size += sizeof(UWord);
+	size = fix[ix].type_size;
 	if (fix[ix].limit < fix[ix].used)
 	    fix[ix].limit = fix[ix].used;
 	if (fix[ix].max_used < fix[ix].used)
@@ -4198,9 +4207,8 @@ erts_alcu_start(Allctr_t *allctr, AllctrInit_t *init)
 #if ERTS_SMP
     if (init->tpref) {
 	Uint sz = ABLK_HDR_SZ;
-	sz += ERTS_ALCU_DD_FIX_TYPE_OFFS*sizeof(UWord);
-	if (init->fix)
-	    sz += sizeof(UWord);
+	sz += (init->fix ? 
+	       sizeof(ErtsAllctrFixDDBlock_t) : sizeof(ErtsAllctrDDBlock_t));
 	sz = UNIT_CEILING(sz);
 	if (sz > allctr->min_block_size)
 	    allctr->min_block_size = sz;
@@ -4325,6 +4333,9 @@ erts_alcu_start(Allctr_t *allctr, AllctrInit_t *init)
 	    allctr->fix[i].list = NULL;
 	    allctr->fix[i].allocated = 0;
 	    allctr->fix[i].used = 0;
+#ifdef ERTS_SMP
+	    ASSERT(allctr->fix[i].type_size >= sizeof(ErtsAllctrFixDDBlock_t));
+#endif
 	}
     }
 
diff --git a/erts/emulator/beam/erl_instrument.c b/erts/emulator/beam/erl_instrument.c
index b5b245288b..1aea3f65bc 100644
--- a/erts/emulator/beam/erl_instrument.c
+++ b/erts/emulator/beam/erl_instrument.c
@@ -271,6 +271,18 @@ stat_upd_realloc(ErtsAlcType_t n, Uint size, Uint old_size)
  * stat instrumentation callback functions
  */
 
+static void stat_pre_lock(void)
+{
+    erts_mtx_lock(&instr_mutex);
+}
+
+static void stat_pre_unlock(void)
+{
+    erts_mtx_unlock(&instr_mutex);
+}
+
+static ErtsAllocatorWrapper_t instr_wrapper;
+
 static void *
 stat_alloc(ErtsAlcType_t n, void *extra, Uint size)
 {
@@ -278,7 +290,9 @@ stat_alloc(ErtsAlcType_t n, void *extra, Uint size)
     Uint ssize;
     void *res;
 
-    erts_mtx_lock(&instr_mutex);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	erts_mtx_lock(&instr_mutex);
+    }
 
     ssize = size + STAT_BLOCK_HEADER_SIZE;
     res = (*real_af->alloc)(n, real_af->extra, ssize);
@@ -293,7 +307,9 @@ stat_alloc(ErtsAlcType_t n, void *extra, Uint size)
 	res = (void *) ((StatBlock_t *) res)->mem;
     }
 
-    erts_mtx_unlock(&instr_mutex);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	erts_mtx_unlock(&instr_mutex);
+    }
 
     return res;
 }
@@ -307,7 +323,9 @@ stat_realloc(ErtsAlcType_t n, void *extra, void *ptr, Uint size)
     void *sptr;
     void *res;
 
-    erts_mtx_lock(&instr_mutex);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	erts_mtx_lock(&instr_mutex);
+    }
 
     if (ptr) {
 	sptr = (void *) (((char *) ptr) - STAT_BLOCK_HEADER_SIZE);
@@ -329,7 +347,9 @@ stat_realloc(ErtsAlcType_t n, void *extra, void *ptr, Uint size)
 	res = (void *) ((StatBlock_t *) res)->mem;
     }
 
-    erts_mtx_unlock(&instr_mutex);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	erts_mtx_unlock(&instr_mutex);
+    }
 
     return res;
 }
@@ -340,7 +360,9 @@ stat_free(ErtsAlcType_t n, void *extra, void *ptr)
     ErtsAllocatorFunctions_t *real_af = (ErtsAllocatorFunctions_t *) extra;
     void *sptr;
 
-    erts_mtx_lock(&instr_mutex);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	erts_mtx_lock(&instr_mutex);
+    }
 
     if (ptr) {
 	sptr = (void *) (((char *) ptr) - STAT_BLOCK_HEADER_SIZE);
@@ -352,7 +374,9 @@ stat_free(ErtsAlcType_t n, void *extra, void *ptr)
 
     (*real_af->free)(n, real_af->extra, sptr);
 
-    erts_mtx_unlock(&instr_mutex);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	erts_mtx_unlock(&instr_mutex);
+    }
 
 }
 
@@ -360,6 +384,18 @@ stat_free(ErtsAlcType_t n, void *extra, void *ptr)
  * map stat instrumentation callback functions
  */
 
+static void map_stat_pre_lock(void)
+{
+    erts_mtx_lock(&instr_x_mutex);
+    erts_mtx_lock(&instr_mutex);
+}
+
+static void map_stat_pre_unlock(void)
+{
+    erts_mtx_unlock(&instr_mutex);
+    erts_mtx_unlock(&instr_x_mutex);
+}
+
 static void *
 map_stat_alloc(ErtsAlcType_t n, void *extra, Uint size)
 {
@@ -367,7 +403,9 @@ map_stat_alloc(ErtsAlcType_t n, void *extra, Uint size)
     Uint msize;
     void *res;
 
-    erts_mtx_lock(&instr_mutex);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	erts_mtx_lock(&instr_mutex);
+    }
 
     msize = size + MAP_STAT_BLOCK_HEADER_SIZE;
     res = (*real_af->alloc)(n, real_af->extra, msize);
@@ -388,7 +426,9 @@ map_stat_alloc(ErtsAlcType_t n, void *extra, Uint size)
 	res = (void *) mb->mem;
     }
 
-    erts_mtx_unlock(&instr_mutex);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	erts_mtx_unlock(&instr_mutex);
+    }
 
     return res;
 }
@@ -402,8 +442,10 @@ map_stat_realloc(ErtsAlcType_t n, void *extra, void *ptr, Uint size)
     void *mptr;
     void *res;
 
-    erts_mtx_lock(&instr_x_mutex);
-    erts_mtx_lock(&instr_mutex);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	erts_mtx_lock(&instr_x_mutex);
+	erts_mtx_lock(&instr_mutex);
+    }
 
     if (ptr) {
 	mptr = (void *) (((char *) ptr) - MAP_STAT_BLOCK_HEADER_SIZE);
@@ -449,9 +491,10 @@ map_stat_realloc(ErtsAlcType_t n, void *extra, void *ptr, Uint size)
 
 	res = (void *) mb->mem;
     }
-
-    erts_mtx_unlock(&instr_mutex);
-    erts_mtx_unlock(&instr_x_mutex);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	erts_mtx_unlock(&instr_mutex);
+	erts_mtx_unlock(&instr_x_mutex);
+    }
 
     return res;
 }
@@ -462,8 +505,10 @@ map_stat_free(ErtsAlcType_t n, void *extra, void *ptr)
     ErtsAllocatorFunctions_t *real_af = (ErtsAllocatorFunctions_t *) extra;
     void *mptr;
 
-    erts_mtx_lock(&instr_x_mutex);
-    erts_mtx_lock(&instr_mutex);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	erts_mtx_lock(&instr_x_mutex);
+	erts_mtx_lock(&instr_mutex);
+    }
 
     if (ptr) {
 	MapStatBlock_t *mb;
@@ -486,8 +531,10 @@ map_stat_free(ErtsAlcType_t n, void *extra, void *ptr)
 
     (*real_af->free)(n, real_af->extra, mptr);
 
-    erts_mtx_unlock(&instr_mutex);
-    erts_mtx_unlock(&instr_x_mutex);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	erts_mtx_unlock(&instr_mutex);
+	erts_mtx_unlock(&instr_x_mutex);
+    }
 
 }
 
@@ -496,8 +543,10 @@ static void dump_memory_map_to_stream(FILE *fp)
     ErtsAlcType_t n;
     MapStatBlock_t *bp;
     int lock = !ERTS_IS_CRASH_DUMPING;
-    if (lock)
+    if (lock) {
+	ASSERT(!erts_is_allctr_wrapper_prelocked());
 	erts_mtx_lock(&instr_mutex);
+    }
 
     /* Write header */
 
@@ -1155,6 +1204,7 @@ erts_instr_get_type_info(Process *proc)
 Uint
 erts_instr_init(int stat, int map_stat)
 {
+    Uint extra_sz;
     int i;
 
     am_tot = NULL;
@@ -1208,7 +1258,9 @@ erts_instr_init(int stat, int map_stat)
 	    erts_allctrs[i].free	= map_stat_free;
 	    erts_allctrs[i].extra	= (void *) &real_allctrs[i];
 	}
-	return MAP_STAT_BLOCK_HEADER_SIZE;
+	instr_wrapper.lock = map_stat_pre_lock;
+	instr_wrapper.unlock = map_stat_pre_unlock;
+	extra_sz = MAP_STAT_BLOCK_HEADER_SIZE;
     }
     else {
 	erts_instr_stat = 1;
@@ -1220,8 +1272,11 @@ erts_instr_init(int stat, int map_stat)
 	    erts_allctrs[i].free	= stat_free;
 	    erts_allctrs[i].extra	= (void *) &real_allctrs[i];
 	}
-	return STAT_BLOCK_HEADER_SIZE;
+	instr_wrapper.lock = stat_pre_lock;
+	instr_wrapper.unlock = stat_pre_unlock;
+	extra_sz = STAT_BLOCK_HEADER_SIZE;
     }
-
+    erts_allctr_wrapper_prelock_init(&instr_wrapper);
+    return extra_sz;
 }
 
diff --git a/erts/emulator/beam/erl_lock_check.c b/erts/emulator/beam/erl_lock_check.c
index 69bb4be717..a1d270adba 100644
--- a/erts/emulator/beam/erl_lock_check.c
+++ b/erts/emulator/beam/erl_lock_check.c
@@ -143,6 +143,8 @@ static erts_lc_lock_order_t erts_lock_order[] = {
     {	"ptimer_pre_alloc_lock",		"address",		},
     {	"btm_pre_alloc_lock",			NULL,			},
     {	"dist_entry_out_queue",			"address"		},
+    {	"port_sched_lock",			"port_id"		},
+    {   "port_table",                           NULL                    },
 #endif
     {	"mtrace_op",				NULL			},
     {	"instr_x",				NULL			},
@@ -154,10 +156,8 @@ static erts_lc_lock_order_t erts_lock_order[] = {
     {	"pmmap",				NULL			},
 #endif
 #ifdef ERTS_SMP
-    {	"port_sched_lock",			"port_id"		},
     {	"port_task_pre_alloc_lock",		"address"		},
     {	"proclist_pre_alloc_lock",		"address"		},
-    {   "port_table",                           NULL                    },
     {	"xports_list_pre_alloc_lock",		"address"		},
     {	"inet_buffer_stack_lock",		NULL			},
     {	"gc_info",				NULL			},
diff --git a/erts/emulator/beam/erl_mtrace.c b/erts/emulator/beam/erl_mtrace.c
index e538ba30c2..c8bb126687 100644
--- a/erts/emulator/beam/erl_mtrace.c
+++ b/erts/emulator/beam/erl_mtrace.c
@@ -222,6 +222,8 @@ static byte *tracep;
 static byte *endp;
 static SysTimeval last_tv;
 
+static ErtsAllocatorWrapper_t mtrace_wrapper;
+
 #if ERTS_MTRACE_SEGMENT_ID >= ERTS_ALC_A_MIN || ERTS_MTRACE_SEGMENT_ID < 0
 #error ERTS_MTRACE_SEGMENT_ID >= ERTS_ALC_A_MIN || ERTS_MTRACE_SEGMENT_ID < 0
 #endif
@@ -555,6 +557,8 @@ write_trace_header(char *nodename, char *pid, char *hostname)
     return 1;
 }
 
+static void mtrace_pre_lock(void);
+static void mtrace_pre_unlock(void);
 static void *mtrace_alloc(ErtsAlcType_t, void *, Uint);
 static void *mtrace_realloc(ErtsAlcType_t, void *, void *, Uint);
 static void mtrace_free(ErtsAlcType_t, void *, void *);
@@ -635,12 +639,16 @@ erts_mtrace_install_wrapper_functions(void)
 	    erts_allctrs[i].free	= mtrace_free;
 	    erts_allctrs[i].extra	= (void *) &real_allctrs[i];
 	}
+	mtrace_wrapper.lock = mtrace_pre_lock;
+	mtrace_wrapper.unlock = mtrace_pre_unlock;
+	erts_allctr_wrapper_prelock_init(&mtrace_wrapper);
     }
 }
 
 void
 erts_mtrace_stop(void)
 {
+    ASSERT(!erts_is_allctr_wrapper_prelocked());
     erts_mtx_lock(&mtrace_op_mutex);
     erts_mtx_lock(&mtrace_buf_mutex);
     if (erts_mtrace_enabled) {
@@ -677,6 +685,7 @@ erts_mtrace_stop(void)
 void
 erts_mtrace_exit(Uint32 exit_value)
 {
+    ASSERT(!erts_is_allctr_wrapper_prelocked());
     erts_mtx_lock(&mtrace_op_mutex);
     erts_mtx_lock(&mtrace_buf_mutex);
     if (erts_mtrace_enabled) {
@@ -935,18 +944,33 @@ write_free_entry(byte tag,
     erts_mtx_unlock(&mtrace_buf_mutex);
 }
 
+static void mtrace_pre_lock(void)
+{
+    erts_mtx_lock(&mtrace_op_mutex);
+}
+
+static void mtrace_pre_unlock(void)
+{
+    erts_mtx_unlock(&mtrace_op_mutex);
+}
+
+
 static void *
 mtrace_alloc(ErtsAlcType_t n, void *extra, Uint size)
 {
     ErtsAllocatorFunctions_t *real_af = (ErtsAllocatorFunctions_t *) extra;
     void *res;
 
-    erts_mtx_lock(&mtrace_op_mutex);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	erts_mtx_lock(&mtrace_op_mutex);
+    }
 
     res = (*real_af->alloc)(n, real_af->extra, size);
     write_alloc_entry(ERTS_MT_ALLOC_BDY_TAG, res, n, 0, size);
 
-    erts_mtx_unlock(&mtrace_op_mutex);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	erts_mtx_unlock(&mtrace_op_mutex);
+    }
 
     return res;
 }
@@ -957,12 +981,16 @@ mtrace_realloc(ErtsAlcType_t n, void *extra, void *ptr, Uint size)
     ErtsAllocatorFunctions_t *real_af = (ErtsAllocatorFunctions_t *) extra;
     void *res;
 
-    erts_mtx_lock(&mtrace_op_mutex);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	erts_mtx_lock(&mtrace_op_mutex);
+    }
 
     res = (*real_af->realloc)(n, real_af->extra, ptr, size);
     write_realloc_entry(ERTS_MT_REALLOC_BDY_TAG, res, n, 0, ptr, size);
 
-    erts_mtx_unlock(&mtrace_op_mutex);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	erts_mtx_unlock(&mtrace_op_mutex);
+    }
 
     return res;
 
@@ -973,10 +1001,14 @@ mtrace_free(ErtsAlcType_t n, void *extra, void *ptr)
 {
     ErtsAllocatorFunctions_t *real_af = (ErtsAllocatorFunctions_t *) extra;
 
-    erts_mtx_lock(&mtrace_op_mutex);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	erts_mtx_lock(&mtrace_op_mutex);
+    }
 
     (*real_af->free)(n, real_af->extra, ptr);
-    write_free_entry(ERTS_MT_FREE_BDY_TAG, n, 0, ptr);
+    if (!erts_is_allctr_wrapper_prelocked()) {
+	write_free_entry(ERTS_MT_FREE_BDY_TAG, n, 0, ptr);
+    }
 
     erts_mtx_unlock(&mtrace_op_mutex);
 }
diff --git a/erts/emulator/beam/external.c b/erts/emulator/beam/external.c
index 5ce0d97c74..8420cfae24 100644
--- a/erts/emulator/beam/external.c
+++ b/erts/emulator/beam/external.c
@@ -3147,17 +3147,6 @@ encode_size_struct2(ErtsAtomCacheMap *acmp, Eterm obj, unsigned dflags)
     return result;
 }
 
-static int is_valid_utf8_atom(byte* bytes, Uint nbytes)
-{
-    byte* err_pos;
-    Uint num_chars;
-
-    /*SVERK Do we really need to validate correct utf8? */
-    return nbytes <= MAX_ATOM_SZ_LIMIT
-	&& erts_analyze_utf8(bytes, nbytes, &err_pos, &num_chars, NULL) == ERTS_UTF8_OK
-	&& num_chars <= MAX_ATOM_CHARACTERS; 
-}
-
 static Sint
 decoded_size(byte *ep, byte* endp, int internal_tags)
 {
@@ -3235,7 +3224,7 @@ decoded_size(byte *ep, byte* endp, int internal_tags)
 	    CHKSIZE(2);
 	    n = get_int16(ep);
 	    ep += 2;
-	    if (!is_valid_utf8_atom(ep, n)) {
+	    if (n > MAX_ATOM_SZ_LIMIT) {
 		return -1;
 	    }
 	    SKIP(n+atom_extra_skip);
@@ -3254,7 +3243,7 @@ decoded_size(byte *ep, byte* endp, int internal_tags)
 	    CHKSIZE(1);
 	    n = get_int8(ep);
 	    ep++;
-	    if (!is_valid_utf8_atom(ep, n)) {
+	    if (n > MAX_ATOM_SZ_LIMIT) {
 		return -1;
 	    }
 	    SKIP(n+atom_extra_skip);