Replace system block with thread progress block

The ERTS internal system block functionality has been replaced by
new functionality for blocking the system. The old system block
functionality had contention issues and complexity issues. The
new functionality piggy-backs on thread progress tracking functionality
needed by newly introduced lock-free synchronization in the runtime
system. When the functionality for blocking the system isn't used
there is more or less no overhead at all. This since the functionality
for tracking thread progress is there and needed anyway.

29 files changed, 845 insertions, 1351 deletions

diff --git a/erts/emulator/beam/beam_bif_load.c b/erts/emulator/beam/beam_bif_load.c
index 2561d7a630..e6dba10fde 100644
--- a/erts/emulator/beam/beam_bif_load.c
+++ b/erts/emulator/beam/beam_bif_load.c
@@ -33,6 +33,7 @@
 #include "beam_catches.h"
 #include "erl_binary.h"
 #include "erl_nif.h"
+#include "erl_thr_progress.h"
 
 static void set_default_trace_pattern(Eterm module);
 static Eterm check_process_code(Process* rp, Module* modp);
@@ -64,7 +65,7 @@ load_module_2(BIF_ALIST_2)
 	goto error;
     }
     erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-    erts_smp_block_system(0);
+    erts_smp_thr_progress_block();
 
     erts_export_consolidate();
 
@@ -103,7 +104,7 @@ load_module_2(BIF_ALIST_2)
 
  done:
     erts_free_aligned_binary_bytes(temp_alloc);
-    erts_smp_release_system();
+    erts_smp_thr_progress_unblock();
     erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 
     BIF_RET(res);
@@ -118,12 +119,12 @@ BIF_RETTYPE purge_module_1(BIF_ALIST_1)
     }
 
     erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-    erts_smp_block_system(0);
+    erts_smp_thr_progress_block();
 
     erts_export_consolidate();
     purge_res = purge_module(atom_val(BIF_ARG_1));
 
-    erts_smp_release_system();
+    erts_smp_thr_progress_unblock();
     erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 
     if (purge_res < 0) {
@@ -152,12 +153,12 @@ BIF_RETTYPE code_make_stub_module_3(BIF_ALIST_3)
     Eterm res;
 
     erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-    erts_smp_block_system(0);
+    erts_smp_thr_progress_block();
 
     erts_export_consolidate();
     res = erts_make_stub_module(BIF_P, BIF_ARG_1, BIF_ARG_2, BIF_ARG_3);
 
-    erts_smp_release_system();
+    erts_smp_thr_progress_unblock();
     erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
     return res;
 }
@@ -239,7 +240,7 @@ BIF_RETTYPE delete_module_1(BIF_ALIST_1)
 	goto badarg;
 
     erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-    erts_smp_block_system(0);
+    erts_smp_thr_progress_block();
 
     {
 	Module *modp = erts_get_module(BIF_ARG_1);
@@ -260,7 +261,7 @@ BIF_RETTYPE delete_module_1(BIF_ALIST_1)
 	}
     }
 
-    erts_smp_release_system();
+    erts_smp_thr_progress_unblock();
     erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 
     if (res == am_badarg) {
@@ -352,7 +353,7 @@ BIF_RETTYPE finish_after_on_load_2(BIF_ALIST_2)
     }
 
     erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-    erts_smp_block_system(0);
+    erts_smp_thr_progress_block();
 
     if (BIF_ARG_2 == am_true) {
 	int i;
@@ -391,7 +392,7 @@ BIF_RETTYPE finish_after_on_load_2(BIF_ALIST_2)
 	modp->catches = BEAM_CATCHES_NIL;
 	remove_from_address_table(code);
     }
-    erts_smp_release_system();
+    erts_smp_thr_progress_unblock();
     erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
     BIF_RET(am_true);
 }
@@ -728,10 +729,10 @@ delete_code(Process *c_p, ErtsProcLocks c_p_locks, Module* modp)
     if (modp->code != NULL && modp->code[MI_NUM_BREAKPOINTS] > 0) {
 	if (c_p && c_p_locks)
 	    erts_smp_proc_unlock(c_p, ERTS_PROC_LOCK_MAIN);
-	erts_smp_block_system(0);
+	erts_smp_thr_progress_block();
 	erts_clear_module_break(modp);
 	modp->code[MI_NUM_BREAKPOINTS] = 0;
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	if (c_p && c_p_locks)
 	    erts_smp_proc_lock(c_p, ERTS_PROC_LOCK_MAIN);
     }
diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 773baad01f..67748698e1 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -167,7 +167,7 @@ erts_bp_init(void) {
 int 
 erts_set_trace_break(Eterm mfa[3], int specified, Binary *match_spec,
 		     Eterm tracer_pid) {
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     return set_break(mfa, specified, match_spec,
 		     (BeamInstr) BeamOp(op_i_trace_breakpoint), 0, tracer_pid);
 }
@@ -175,7 +175,7 @@ erts_set_trace_break(Eterm mfa[3], int specified, Binary *match_spec,
 int 
 erts_set_mtrace_break(Eterm mfa[3], int specified, Binary *match_spec,
 		      Eterm tracer_pid) {
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     return set_break(mfa, specified, match_spec,
 		     (BeamInstr) BeamOp(op_i_mtrace_breakpoint), 0, tracer_pid);
 }
@@ -184,7 +184,7 @@ erts_set_mtrace_break(Eterm mfa[3], int specified, Binary *match_spec,
 
 void
 erts_set_mtrace_bif(BeamInstr *pc, Binary *match_spec, Eterm tracer_pid) {
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     set_function_break(NULL, pc, BREAK_IS_BIF, match_spec, (BeamInstr) BeamOp(op_i_mtrace_breakpoint), 0, tracer_pid);
 }
 
@@ -198,35 +198,35 @@ void erts_clear_time_trace_bif(BeamInstr *pc) {
 
 int 
 erts_set_debug_break(Eterm mfa[3], int specified) {
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     return set_break(mfa, specified, NULL, 
 		     (BeamInstr) BeamOp(op_i_debug_breakpoint), 0, NIL);
 }
 
 int 
 erts_set_count_break(Eterm mfa[3], int specified, enum erts_break_op count_op) {
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     return set_break(mfa, specified, NULL, 
 		     (BeamInstr) BeamOp(op_i_count_breakpoint), count_op, NIL);
 }
 
 int
 erts_set_time_break(Eterm mfa[3], int specified, enum erts_break_op count_op) {
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     return set_break(mfa, specified, NULL,
 		     (BeamInstr) BeamOp(op_i_time_breakpoint), count_op, NIL);
 }
 
 int
 erts_clear_trace_break(Eterm mfa[3], int specified) {
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     return clear_break(mfa, specified, 
 		       (BeamInstr) BeamOp(op_i_trace_breakpoint));
 }
 
 int
 erts_clear_mtrace_break(Eterm mfa[3], int specified) {
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     return clear_break(mfa, specified, 
 		       (BeamInstr) BeamOp(op_i_mtrace_breakpoint));
 }
@@ -238,41 +238,41 @@ erts_clear_mtrace_bif(BeamInstr *pc) {
 
 int
 erts_clear_debug_break(Eterm mfa[3], int specified) {
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     return clear_break(mfa, specified, 
 		       (BeamInstr) BeamOp(op_i_debug_breakpoint));
 }
 
 int
 erts_clear_count_break(Eterm mfa[3], int specified) {
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     return clear_break(mfa, specified, 
 		       (BeamInstr) BeamOp(op_i_count_breakpoint));
 }
 
 int
 erts_clear_time_break(Eterm mfa[3], int specified) {
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     return clear_break(mfa, specified,
 		       (BeamInstr) BeamOp(op_i_time_breakpoint));
 }
 
 int
 erts_clear_break(Eterm mfa[3], int specified) {
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     return clear_break(mfa, specified, 0);
 }
 
 int 
 erts_clear_module_break(Module *modp) {
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     ASSERT(modp);
     return clear_module_break(modp, NULL, 0, 0);
 }
 
 int
 erts_clear_function_break(Module *modp, BeamInstr *pc) {
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
     ASSERT(modp);
     return clear_function_break(modp, pc, BREAK_IS_ERL, 0);
 }
@@ -975,7 +975,7 @@ static int set_function_break(Module *modp, BeamInstr *pc, int bif,
 		BpDataTime *bdt = (BpDataTime *) bd;
 		Uint i = 0;
 
-		ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+		ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
 
 		if (count_op == erts_break_stop) {
 		    bdt->pause = 1;
diff --git a/erts/emulator/beam/beam_debug.c b/erts/emulator/beam/beam_debug.c
index fffb172c68..2b4448f93b 100644
--- a/erts/emulator/beam/beam_debug.c
+++ b/erts/emulator/beam/beam_debug.c
@@ -37,6 +37,7 @@
 #include "beam_load.h"
 #include "beam_bp.h"
 #include "erl_binary.h"
+#include "erl_thr_progress.h"
 
 #ifdef ARCH_64
 # define HEXF "%016bpX"
@@ -107,7 +108,7 @@ erts_debug_breakpoint_2(Process* p, Eterm MFA, Eterm bool)
     }
 
     erts_smp_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
-    erts_smp_block_system(0);
+    erts_smp_thr_progress_block();
 
     if (bool == am_true) {
 	res = make_small(erts_set_debug_break(mfa, specified));
@@ -115,7 +116,7 @@ erts_debug_breakpoint_2(Process* p, Eterm MFA, Eterm bool)
 	res = make_small(erts_clear_debug_break(mfa, specified));
     }
 
-    erts_smp_release_system();
+    erts_smp_thr_progress_unblock();
     erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
 
     return res;
diff --git a/erts/emulator/beam/beam_emu.c b/erts/emulator/beam/beam_emu.c
index 937b3d9e53..73c9fdc5d7 100644
--- a/erts/emulator/beam/beam_emu.c
+++ b/erts/emulator/beam/beam_emu.c
@@ -36,6 +36,7 @@
 #include "dist.h"
 #include "beam_bp.h"
 #include "beam_catches.h"
+#include "erl_thr_progress.h"
 #ifdef HIPE
 #include "hipe_mode_switch.h"
 #include "hipe_bif1.h"
@@ -70,7 +71,7 @@ do {									\
     }									\
     else								\
 	erts_lc_check_exact(NULL, 0);					\
-    ERTS_SMP_LC_ASSERT(!ERTS_LC_IS_BLOCKING);				\
+    	ERTS_SMP_LC_ASSERT(!erts_thr_progress_is_blocking());		\
 } while (0)
 #    define ERTS_SMP_REQ_PROC_MAIN_LOCK(P) \
         if ((P)) erts_proc_lc_require_lock((P), ERTS_PROC_LOCK_MAIN)
diff --git a/erts/emulator/beam/bif.c b/erts/emulator/beam/bif.c
index 98dde066fc..8edc863767 100644
--- a/erts/emulator/beam/bif.c
+++ b/erts/emulator/beam/bif.c
@@ -36,6 +36,7 @@
 #include "beam_bp.h"
 #include "erl_db_util.h"
 #include "register.h"
+#include "erl_thr_progress.h"
 
 static Export* flush_monitor_message_trap = NULL;
 static Export* set_cpu_topology_trap = NULL;
@@ -3953,11 +3954,11 @@ BIF_RETTYPE system_flag_2(BIF_ALIST_2)
 	}
 
 	erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-	erts_smp_block_system(0);
+	erts_smp_thr_progress_block();
 
 	H_MIN_SIZE = erts_next_heap_size(n, 0);
 
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 
 	BIF_RET(make_small(oval));
@@ -3969,11 +3970,11 @@ BIF_RETTYPE system_flag_2(BIF_ALIST_2)
 	}
 
 	erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-	erts_smp_block_system(0);
+	erts_smp_thr_progress_block();
 
 	BIN_VH_MIN_SIZE = erts_next_heap_size(n, 0);
 
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 
 	BIF_RET(make_small(oval));
@@ -4007,7 +4008,7 @@ BIF_RETTYPE system_flag_2(BIF_ALIST_2)
 	Uint i;
 	ErlMessage* mp;
 	erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-	erts_smp_block_system(0);
+	erts_smp_thr_progress_block();
 
 	for (i = 0; i < erts_max_processes; i++) {
 	    if (process_tab[i] != (Process*) 0) {
@@ -4024,7 +4025,7 @@ BIF_RETTYPE system_flag_2(BIF_ALIST_2)
 	    }
 	}
 
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 
 	BIF_RET(am_true);
diff --git a/erts/emulator/beam/break.c b/erts/emulator/beam/break.c
index 432b3d0780..8d37ae9f9b 100644
--- a/erts/emulator/beam/break.c
+++ b/erts/emulator/beam/break.c
@@ -37,6 +37,7 @@
 #include "beam_load.h"
 #include "erl_instrument.h"
 #include "erl_bif_timer.h"
+#include "erl_thr_progress.h"
 
 /* Forward declarations -- should really appear somewhere else */
 static void process_killer(void);
@@ -653,20 +654,18 @@ erl_crash_dump_v(char *file, int line, char* fmt, va_list args)
     if (ERTS_SOMEONE_IS_CRASH_DUMPING)
 	return;
 
-    /* Wait for all threads to block. If all threads haven't blocked
+#ifdef ERTS_SMP
+    /*
+     * Wait for all managed threads to block. If all threads haven't blocked
      * after a minute, we go anyway and hope for the best...
      *
      * We do not release system again. We expect an exit() or abort() after
      * dump has been written.
-     *
-     * NOTE: We allow gc therefore it is important not to lock *any*
-     *       process locks.
      */
-    erts_smp_emergency_block_system(60000, ERTS_BS_FLG_ALLOW_GC);
+    erts_thr_progress_fatal_error_block(60000);
     /* Either worked or not... */
 
     /* Allow us to pass certain places without locking... */
-#ifdef ERTS_SMP
     erts_smp_atomic32_set_mb(&erts_writing_erl_crash_dump, 1);
     erts_smp_tsd_set(erts_is_crash_dumping_key, (void *) 1);
 #else
diff --git a/erts/emulator/beam/dist.c b/erts/emulator/beam/dist.c
index ad042ec088..d62eed21b4 100644
--- a/erts/emulator/beam/dist.c
+++ b/erts/emulator/beam/dist.c
@@ -41,6 +41,7 @@
 #include "bif.h"
 #include "external.h"
 #include "erl_binary.h"
+#include "erl_thr_progress.h"
 
 /* Turn this on to get printouts of all distribution messages
  * which go on the line
@@ -430,11 +431,11 @@ int erts_do_net_exits(DistEntry *dep, Eterm reason)
 	erts_smp_rwmtx_rwunlock(&erts_dist_table_rwmtx);
 
 	nodename = erts_this_dist_entry->sysname;
-	erts_smp_block_system(ERTS_BS_FLG_ALLOW_GC);
+	erts_smp_thr_progress_block();
 	erts_set_this_node(am_Noname, 0);
 	erts_is_alive = 0;
 	send_nodes_mon_msgs(NULL, am_nodedown, nodename, am_visible, nd_reason);
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 
     }
     else { /* recursive call via erts_do_exit_port() will end up here */
@@ -2330,11 +2331,11 @@ BIF_RETTYPE setnode_2(BIF_ALIST_2)
 #endif
 
     erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-    erts_smp_block_system(ERTS_BS_FLG_ALLOW_GC);
+    erts_smp_thr_progress_block();
     erts_set_this_node(BIF_ARG_1, (Uint32) creation);
     erts_is_alive = 1;
     send_nodes_mon_msgs(NULL, am_nodeup, BIF_ARG_1, am_visible, NIL);
-    erts_smp_release_system();
+    erts_smp_thr_progress_unblock();
     erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 
     BIF_RET(am_true);
diff --git a/erts/emulator/beam/erl_alloc.c b/erts/emulator/beam/erl_alloc.c
index 80951c9b50..705ace26fa 100644
--- a/erts/emulator/beam/erl_alloc.c
+++ b/erts/emulator/beam/erl_alloc.c
@@ -1866,9 +1866,7 @@ erts_memory(int *print_to_p, void *print_to_arg, void *proc, Eterm earg)
     int only_one_value = 0;
     ErtsAlcUFixInfo_t fi[ERTS_ALC_NO_FIXED_SIZES] = {{0,0}};
 
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0)
-		       || (ERTS_IS_CRASH_DUMPING
-			   && erts_smp_is_system_blocked(ERTS_BS_FLG_ALLOW_GC)));
+    ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
 
     /* Figure out whats wanted... */
 
@@ -2506,9 +2504,7 @@ erts_allocator_info(int to, void *arg)
 {
     ErtsAlcType_t a;
 
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0)
-		       || (ERTS_IS_CRASH_DUMPING
-			   && erts_smp_is_system_blocked(ERTS_BS_FLG_ALLOW_GC)));
+    ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
 
     for (a = ERTS_ALC_A_MIN; a <= ERTS_ALC_A_MAX; a++) {
 	int ai;
diff --git a/erts/emulator/beam/erl_alloc.types b/erts/emulator/beam/erl_alloc.types
index 7a27ee28ec..79d3433fc0 100644
--- a/erts/emulator/beam/erl_alloc.types
+++ b/erts/emulator/beam/erl_alloc.types
@@ -272,6 +272,7 @@ type	MISC_AUX_WORK_Q	LONG_LIVED	SYSTEM		misc_aux_work_q
 type	MISC_AUX_WORK	SHORT_LIVED	SYSTEM		misc_aux_work
 type	THR_PRGR_IDATA	LONG_LIVED	SYSTEM		thr_prgr_internal_data
 type	THR_PRGR_DATA	LONG_LIVED	SYSTEM		thr_prgr_data
+type	T_THR_PRGR_DATA	SHORT_LIVED	SYSTEM		temp_thr_prgr_data
 +endif
 
 #
diff --git a/erts/emulator/beam/erl_alloc_util.c b/erts/emulator/beam/erl_alloc_util.c
index daf8822564..af386c9197 100644
--- a/erts/emulator/beam/erl_alloc_util.c
+++ b/erts/emulator/beam/erl_alloc_util.c
@@ -482,9 +482,7 @@ do {									\
 	else {								\
 	    ERTS_SMP_LC_ASSERT(						\
 		ethr_equal_tids((A)->debug.tid, erts_thr_self())	\
-		|| erts_is_system_blocked(ERTS_BS_FLG_ALLOW_GC)		\
-		|| (ERTS_IS_CRASH_DUMPING				\
-		    && erts_is_system_blocked(ERTS_BS_FLG_ALLOW_GC)));	\
+		|| erts_thr_progress_is_blocking());			\
 	}								\
     }									\
 } while (0)
diff --git a/erts/emulator/beam/erl_bif_info.c b/erts/emulator/beam/erl_bif_info.c
index 70d728340a..58eb58d1dc 100644
--- a/erts/emulator/beam/erl_bif_info.c
+++ b/erts/emulator/beam/erl_bif_info.c
@@ -39,6 +39,7 @@
 #include "dist.h"
 #include "erl_gc.h"
 #include "erl_cpu_topology.h"
+#include "erl_thr_progress.h"
 #ifdef HIPE
 #include "hipe_arch.h"
 #endif
@@ -2087,7 +2088,7 @@ BIF_RETTYPE system_info_1(BIF_ALIST_1)
 
 	/* Need to be the only thread running... */
 	erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-	erts_smp_block_system(0);
+	erts_smp_thr_progress_block();
 
 	if (BIF_ARG_1 == am_info)
 	    info(ERTS_PRINT_DSBUF, (void *) dsbufp);
@@ -2098,7 +2099,7 @@ BIF_RETTYPE system_info_1(BIF_ALIST_1)
 	else
 	    distribution_info(ERTS_PRINT_DSBUF, (void *) dsbufp);
 
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 
 	ASSERT(dsbufp && dsbufp->str);
@@ -2110,7 +2111,7 @@ BIF_RETTYPE system_info_1(BIF_ALIST_1)
 	i = 0;
 	/* Need to be the only thread running... */
 	erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-	erts_smp_block_system(0);
+	erts_smp_thr_progress_block();
 	for (dep = erts_visible_dist_entries; dep; dep = dep->next) 
 	    ++i;
 	for (dep = erts_hidden_dist_entries; dep; dep = dep->next)
@@ -2133,7 +2134,7 @@ BIF_RETTYPE system_info_1(BIF_ALIST_1)
 	    res = CONS(hp, tpl, res);
 	    hp += 2;
 	}
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 	BIF_RET(res);
     } else if (BIF_ARG_1 == am_system_version) {
@@ -3306,10 +3307,10 @@ BIF_RETTYPE erts_debug_get_internal_state_1(BIF_ALIST_1)
 	else if (ERTS_IS_ATOM_STR("memory", BIF_ARG_1)) {
 	    Eterm res;
 	    erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-	    erts_smp_block_system(0);
+	    erts_smp_thr_progress_block();
 	    erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 	    res = erts_memory(NULL, NULL, BIF_P, THE_NON_VALUE);
-	    erts_smp_release_system();
+	    erts_smp_thr_progress_unblock();
 	    BIF_RET(res);
 	}
     }
@@ -3565,10 +3566,10 @@ BIF_RETTYPE erts_debug_set_internal_state_2(BIF_ALIST_2)
 		if (ms > 0) {
 		    erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
 		    if (block)
-			erts_smp_block_system(0);
+			erts_smp_thr_progress_block();
 		    while (erts_milli_sleep((long) ms) != 0);
 		    if (block)
-			erts_smp_release_system();
+			erts_smp_thr_progress_unblock();
 		    erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 		}
 		BIF_RET(am_true);
@@ -3778,10 +3779,10 @@ BIF_RETTYPE erts_debug_set_internal_state_2(BIF_ALIST_2)
 	    }
 
 	    erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-	    erts_smp_block_system(0);
+	    erts_smp_thr_progress_block();
 	    old_use_opt = !erts_disable_proc_not_running_opt;
 	    erts_disable_proc_not_running_opt = !use_opt;
-	    erts_smp_release_system();
+	    erts_smp_thr_progress_unblock();
 	    erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 	    BIF_RET(old_use_opt ? am_true : am_false);
 #else
@@ -3953,7 +3954,7 @@ BIF_RETTYPE erts_debug_lock_counters_1(BIF_ALIST_1)
     	Eterm* hp;
 
 	erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-	erts_smp_block_system(0);
+	erts_smp_thr_progress_block();
 
 	erts_lcnt_set_rt_opt(ERTS_LCNT_OPT_SUSPEND);
 	data = erts_lcnt_get_data();
@@ -3971,17 +3972,17 @@ BIF_RETTYPE erts_debug_lock_counters_1(BIF_ALIST_1)
 	
 	erts_lcnt_clear_rt_opt(ERTS_LCNT_OPT_SUSPEND);
 
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 	
 	BIF_RET(res);
     } else if (BIF_ARG_1 == am_clear) {
 	erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-	erts_smp_block_system(0);
+	erts_smp_thr_progress_block();
 
 	erts_lcnt_clear_counters();
 
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 
 	BIF_RET(am_ok);
@@ -3992,7 +3993,7 @@ BIF_RETTYPE erts_debug_lock_counters_1(BIF_ALIST_1)
 	    case 2:
 		if (ERTS_IS_ATOM_STR("copy_save", tp[1])) {
 		    erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-		    erts_smp_block_system(0);
+		    erts_smp_thr_progress_block();
 		    if (tp[2] == am_true) {
 
 			res = erts_lcnt_set_rt_opt(ERTS_LCNT_OPT_COPYSAVE) ? am_true : am_false;
@@ -4002,17 +4003,17 @@ BIF_RETTYPE erts_debug_lock_counters_1(BIF_ALIST_1)
 			res = erts_lcnt_clear_rt_opt(ERTS_LCNT_OPT_COPYSAVE) ? am_true : am_false;
 
 		    } else {
-			erts_smp_release_system();
+			erts_smp_thr_progress_unblock();
 			erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 			BIF_ERROR(BIF_P, BADARG);
 		    }
-		    erts_smp_release_system();
+		    erts_smp_thr_progress_unblock();
 		    erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 		    BIF_RET(res);
 
 		} else if (ERTS_IS_ATOM_STR("process_locks", tp[1])) {
 		    erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-		    erts_smp_block_system(0);
+		    erts_smp_thr_progress_block();
 		    if (tp[2] == am_true) {
 
 			res = erts_lcnt_set_rt_opt(ERTS_LCNT_OPT_PROCLOCK) ? am_true : am_false;
@@ -4022,11 +4023,11 @@ BIF_RETTYPE erts_debug_lock_counters_1(BIF_ALIST_1)
 			res = erts_lcnt_set_rt_opt(ERTS_LCNT_OPT_PROCLOCK) ? am_true : am_false;
 
 		    } else {
-			erts_smp_release_system();
+			erts_smp_thr_progress_unblock();
 			erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 			BIF_ERROR(BIF_P, BADARG);
 		    }
-		    erts_smp_release_system();
+		    erts_smp_thr_progress_unblock();
 		    erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
 		    BIF_RET(res);
 		 }
diff --git a/erts/emulator/beam/erl_bif_timer.c b/erts/emulator/beam/erl_bif_timer.c
index db771bd216..a922a33da3 100644
--- a/erts/emulator/beam/erl_bif_timer.c
+++ b/erts/emulator/beam/erl_bif_timer.c
@@ -26,6 +26,7 @@
 #include "bif.h"
 #include "error.h"
 #include "big.h"
+#include "erl_thr_progress.h"
 
 /****************************************************************************
 ** BIF Timer support
@@ -686,7 +687,7 @@ erts_bif_timer_foreach(void (*func)(Eterm, Eterm, ErlHeapFragment *, void *),
 {
     int i;
 
-    ERTS_SMP_LC_ASSERT(erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_smp_thr_progress_is_blocking());
 
     for (i = 0; i < TIMER_HASH_VEC_SZ; i++) {
 	ErtsBifTimer *btm;
diff --git a/erts/emulator/beam/erl_bif_trace.c b/erts/emulator/beam/erl_bif_trace.c
index 7a08182e18..3e942dcc55 100644
--- a/erts/emulator/beam/erl_bif_trace.c
+++ b/erts/emulator/beam/erl_bif_trace.c
@@ -37,6 +37,7 @@
 #include "erl_version.h"
 #include "beam_bp.h"
 #include "erl_binary.h"
+#include "erl_thr_progress.h"
 
 #define DECL_AM(S) Eterm AM_ ## S = am_atom_put(#S, sizeof(#S) - 1)
 
@@ -97,7 +98,7 @@ trace_pattern_3(Process* p, Eterm MFA, Eterm Pattern, Eterm flaglist)
     Eterm meta_tracer_pid = p->id;
 
     erts_smp_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
-    erts_smp_block_system(0);
+    erts_smp_thr_progress_block();
 
     UseTmpHeap(3,p);
     /*
@@ -326,7 +327,7 @@ trace_pattern_3(Process* p, Eterm MFA, Eterm Pattern, Eterm flaglist)
 
  done:
     UnUseTmpHeap(3,p);
-    erts_smp_release_system();
+    erts_smp_thr_progress_unblock();
     erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
 
     return make_small(matches);
@@ -336,7 +337,7 @@ trace_pattern_3(Process* p, Eterm MFA, Eterm Pattern, Eterm flaglist)
     MatchSetUnref(match_prog_set);
 
     UnUseTmpHeap(3,p);
-    erts_smp_release_system();
+    erts_smp_thr_progress_unblock();
     erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
     BIF_ERROR(p, BADARG);
 }
@@ -630,7 +631,7 @@ trace_3(Process* p, Eterm pid_spec, Eterm how, Eterm list)
 
 #ifdef ERTS_SMP
 	    erts_smp_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
-	    erts_smp_block_system(0);
+	    erts_smp_thr_progress_block();
 	    system_blocked = 1;
 #endif
 
@@ -711,7 +712,7 @@ trace_3(Process* p, Eterm pid_spec, Eterm how, Eterm list)
 
 #ifdef ERTS_SMP
     if (system_blocked) {
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
     }
 #endif
@@ -726,7 +727,7 @@ trace_3(Process* p, Eterm pid_spec, Eterm how, Eterm list)
 
 #ifdef ERTS_SMP
     if (system_blocked) {
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
     }
 #endif
@@ -1060,7 +1061,7 @@ trace_info_func(Process* p, Eterm func_spec, Eterm key)
 #ifdef ERTS_SMP
     if ( (key == am_call_time) || (key == am_all)) {
 	erts_smp_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
-	erts_smp_block_system(0);
+	erts_smp_thr_progress_block();
     }
 #endif
 
@@ -1068,7 +1069,7 @@ trace_info_func(Process* p, Eterm func_spec, Eterm key)
 
 #ifdef ERTS_SMP
     if ( (key == am_call_time) || (key == am_all)) {
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
     }
 #endif
@@ -1852,7 +1853,7 @@ void erts_system_monitor_clear(Process *c_p) {
 #ifdef ERTS_SMP
     if (c_p) {
 	erts_smp_proc_unlock(c_p, ERTS_PROC_LOCK_MAIN);
-	erts_smp_block_system(0);
+	erts_smp_thr_progress_block();
     }
 #endif
     erts_set_system_monitor(NIL);
@@ -1862,7 +1863,7 @@ void erts_system_monitor_clear(Process *c_p) {
     erts_system_monitor_flags.busy_dist_port = 0;
 #ifdef ERTS_SMP
     if (c_p) {
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	erts_smp_proc_lock(c_p, ERTS_PROC_LOCK_MAIN);
     }
 #endif
@@ -1951,7 +1952,7 @@ BIF_RETTYPE system_monitor_2(Process *p, Eterm monitor_pid, Eterm list) {
 
 	system_blocked = 1;
 	erts_smp_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
-	erts_smp_block_system(0);
+	erts_smp_thr_progress_block();
 
 	if (!erts_pid2proc(p, ERTS_PROC_LOCK_MAIN, monitor_pid, 0))
 	    goto error;
@@ -1985,7 +1986,7 @@ BIF_RETTYPE system_monitor_2(Process *p, Eterm monitor_pid, Eterm list) {
 	erts_system_monitor_flags.busy_port = !!busy_port;
 	erts_system_monitor_flags.busy_dist_port = !!busy_dist_port;
 
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
 	BIF_RET(prev);
     }
@@ -1993,7 +1994,7 @@ BIF_RETTYPE system_monitor_2(Process *p, Eterm monitor_pid, Eterm list) {
  error:
 
     if (system_blocked) {
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
     }
 
@@ -2006,7 +2007,7 @@ void erts_system_profile_clear(Process *c_p) {
 #ifdef ERTS_SMP
     if (c_p) {
 	erts_smp_proc_unlock(c_p, ERTS_PROC_LOCK_MAIN);
-	erts_smp_block_system(0);
+	erts_smp_thr_progress_block();
     }
 #endif
     erts_set_system_profile(NIL);
@@ -2016,7 +2017,7 @@ void erts_system_profile_clear(Process *c_p) {
     erts_system_profile_flags.exclusive = 0;
 #ifdef ERTS_SMP
     if (c_p) {
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	erts_smp_proc_lock(c_p, ERTS_PROC_LOCK_MAIN);
     }
 #endif
@@ -2075,7 +2076,7 @@ BIF_RETTYPE system_profile_2(Process *p, Eterm profiler, Eterm list) {
 	system_blocked = 1;
 	
 	erts_smp_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
-	erts_smp_block_system(0);
+	erts_smp_thr_progress_block();
 
 	/* Check if valid process, no locks are taken */
 
@@ -2117,7 +2118,7 @@ BIF_RETTYPE system_profile_2(Process *p, Eterm profiler, Eterm list) {
 	erts_system_profile_flags.runnable_procs = !!runnable_procs;
 	erts_system_profile_flags.exclusive = !!exclusive;
 
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
 	
 	BIF_RET(prev);
@@ -2126,7 +2127,7 @@ BIF_RETTYPE system_profile_2(Process *p, Eterm profiler, Eterm list) {
 
     error:
 	if (system_blocked) {
-	    erts_smp_release_system();
+	    erts_smp_thr_progress_unblock();
 	    erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
     	}
 
diff --git a/erts/emulator/beam/erl_db_util.c b/erts/emulator/beam/erl_db_util.c
index 7dfbb2ed02..68b7b7aa6a 100644
--- a/erts/emulator/beam/erl_db_util.c
+++ b/erts/emulator/beam/erl_db_util.c
@@ -35,6 +35,7 @@
 #include "bif.h"
 #include "big.h"
 #include "erl_binary.h"
+#include "erl_thr_progress.h"
 
 #include "erl_db_util.h"
 
@@ -1734,14 +1735,14 @@ Eterm db_prog_match(Process *c_p, Binary *bprog,
 	if (! atomic_trace) {                               \
             erts_refc_inc(&bprog->refc, 2);                 \
 	    erts_smp_proc_unlock((p), ERTS_PROC_LOCK_MAIN); \
-	    erts_smp_block_system(0);                       \
+	    erts_smp_thr_progress_block();                  \
             atomic_trace = !0;                              \
 	}                                                   \
     } while (0)
 #define END_ATOMIC_TRACE(p)                               \
     do {                                                  \
 	if (atomic_trace) {                               \
-            erts_smp_release_system();                    \
+            erts_smp_thr_progress_unblock();              \
             erts_smp_proc_lock((p), ERTS_PROC_LOCK_MAIN); \
             if (erts_refc_dectest(&bprog->refc, 0) == 0) {\
                 erts_bin_free(bprog);                     \
diff --git a/erts/emulator/beam/erl_gc.c b/erts/emulator/beam/erl_gc.c
index e3445bcdc5..8faaf9f367 100644
--- a/erts/emulator/beam/erl_gc.c
+++ b/erts/emulator/beam/erl_gc.c
@@ -357,8 +357,6 @@ erts_garbage_collect(Process* p, int need, Eterm* objv, int nobj)
     }
     erts_smp_proc_unlock(p, ERTS_PROC_LOCK_STATUS);
 
-    erts_smp_locked_activity_begin(ERTS_ACTIVITY_GC);
-
     ERTS_CHK_OFFHEAP(p);
 
     ErtsGcQuickSanityCheck(p);
@@ -392,8 +390,6 @@ erts_garbage_collect(Process* p, int need, Eterm* objv, int nobj)
         trace_gc(p, am_gc_end);
     }
 
-    erts_smp_locked_activity_end(ERTS_ACTIVITY_GC);
-
     if (erts_system_monitor_long_gc != 0) {
 	Uint ms2, s2, us2;
 	Sint t;
@@ -477,7 +473,6 @@ erts_garbage_collect_hibernate(Process* p)
     p->gcstatus = p->status;
     p->status = P_GARBING;
     erts_smp_proc_unlock(p, ERTS_PROC_LOCK_STATUS);
-    erts_smp_locked_activity_begin(ERTS_ACTIVITY_GC);
     ErtsGcQuickSanityCheck(p);
     ASSERT(p->mbuf_sz == 0);
     ASSERT(p->mbuf == 0);
@@ -591,7 +586,6 @@ erts_garbage_collect_hibernate(Process* p)
     erts_smp_proc_lock(p, ERTS_PROC_LOCK_STATUS);
     p->status = p->gcstatus;
     erts_smp_proc_unlock(p, ERTS_PROC_LOCK_STATUS);
-    erts_smp_locked_activity_end(ERTS_ACTIVITY_GC);
 }
 
 
@@ -616,7 +610,6 @@ erts_garbage_collect_literals(Process* p, Eterm* literals, Uint lit_size)
     p->gcstatus = p->status;
     p->status = P_GARBING;
     erts_smp_proc_unlock(p, ERTS_PROC_LOCK_STATUS);
-    erts_smp_locked_activity_begin(ERTS_ACTIVITY_GC);
 
     /*
      * We assume that the caller has already done a major collection
@@ -719,7 +712,6 @@ erts_garbage_collect_literals(Process* p, Eterm* literals, Uint lit_size)
     erts_smp_proc_lock(p, ERTS_PROC_LOCK_STATUS);
     p->status = p->gcstatus;
     erts_smp_proc_unlock(p, ERTS_PROC_LOCK_STATUS);
-    erts_smp_locked_activity_end(ERTS_ACTIVITY_GC);
 }
 
 static int
diff --git a/erts/emulator/beam/erl_init.c b/erts/emulator/beam/erl_init.c
index ef86e6db5e..f4f2a4d011 100644
--- a/erts/emulator/beam/erl_init.c
+++ b/erts/emulator/beam/erl_init.c
@@ -246,10 +246,6 @@ erl_init(int ncpu)
 {
     init_benchmarking();
 
-#ifdef ERTS_SMP
-    erts_system_block_init();
-#endif
-
     erts_init_monitors();
     erts_init_gc();
     erts_init_time();
@@ -778,6 +774,16 @@ early_init(int *argc, char **argv) /*
 						 -M flags. */
     /* Require allocators */
 #ifdef ERTS_SMP
+    /*
+     * Thread progress management:
+     *
+     * * Managed threads:
+     * ** Scheduler threads (see erl_process.c)
+     * ** Aux thread (see erl_process.c)
+     * ** Sys message dispatcher thread (see erl_trace.c)
+     *
+     * * No unmanaged threads that need to register.
+     */
     erts_thr_progress_init(no_schedulers, no_schedulers+1, 0);
 #endif
     erts_init_utils();
@@ -1499,7 +1505,6 @@ system_cleanup(int exit_code)
 #ifdef ERTS_ENABLE_LOCK_CHECK
     erts_lc_check_exact(NULL, 0);
 #endif
-    erts_smp_block_system(ERTS_BS_FLG_ALLOW_GC); /* We never release it... */
 #endif
 
 #ifdef HYBRID
diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c
index 6e7ac43676..818156fce6 100644
--- a/erts/emulator/beam/erl_nif.c
+++ b/erts/emulator/beam/erl_nif.c
@@ -32,6 +32,7 @@
 #include "error.h"
 #include "big.h"
 #include "beam_bp.h"
+#include "erl_thr_progress.h"
 
 #include <limits.h>
 #include <stddef.h> /* offsetof */
@@ -1160,7 +1161,7 @@ enif_open_resource_type(ErlNifEnv* env,
     ErlNifResourceFlags op = flags;
     Eterm module_am, name_am;
 
-    ASSERT(erts_smp_is_system_blocked(0));
+    ASSERT(erts_smp_thr_progress_is_blocking());
     ASSERT(module_str == NULL); /* for now... */
     module_am = make_atom(env->mod_nif->mod->module);
     name_am = enif_make_atom(env, name_str);
@@ -1454,7 +1455,7 @@ BIF_RETTYPE load_nif_2(BIF_ALIST_2)
 
     /* Block system (is this the right place to do it?) */
     erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
-    erts_smp_block_system(0);
+    erts_smp_thr_progress_block();
 
     /* Find calling module */
     ASSERT(BIF_P->current != NULL);
@@ -1643,7 +1644,7 @@ BIF_RETTYPE load_nif_2(BIF_ALIST_2)
 	erts_sys_ddll_free_error(&errdesc);
     }
 
-    erts_smp_release_system();
+    erts_smp_thr_progress_unblock();
     erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
     erts_free(ERTS_ALC_T_TMP, lib_name);
     BIF_RET(ret);
@@ -1655,7 +1656,7 @@ erts_unload_nif(struct erl_module_nif* lib)
 {
     ErlNifResourceType* rt;
     ErlNifResourceType* next;
-    ASSERT(erts_smp_is_system_blocked(0));
+    ASSERT(erts_smp_thr_progress_is_blocking());
     ASSERT(lib != NULL);
     ASSERT(lib->mod != NULL);
     for (rt = resource_type_list.next;
diff --git a/erts/emulator/beam/erl_node_tables.c b/erts/emulator/beam/erl_node_tables.c
index af3873995e..908ba755ed 100644
--- a/erts/emulator/beam/erl_node_tables.c
+++ b/erts/emulator/beam/erl_node_tables.c
@@ -26,6 +26,7 @@
 #include "dist.h"
 #include "big.h"
 #include "error.h"
+#include "erl_thr_progress.h"
 
 Hash erts_dist_table;
 Hash erts_node_table;
@@ -907,7 +908,7 @@ erts_get_node_and_dist_references(struct process *proc)
 #endif
 
     erts_smp_proc_unlock(proc, ERTS_PROC_LOCK_MAIN);
-    erts_smp_block_system(0);
+    erts_smp_thr_progress_block();
     /* No need to lock any thing since we are alone... */
 
     if (references_atoms_need_init) {
@@ -951,7 +952,7 @@ erts_get_node_and_dist_references(struct process *proc)
 
     delete_reference_table();
 
-    erts_smp_release_system();
+    erts_smp_thr_progress_unblock();
     erts_smp_proc_lock(proc, ERTS_PROC_LOCK_MAIN);
     return res;
 }
diff --git a/erts/emulator/beam/erl_port_task.c b/erts/emulator/beam/erl_port_task.c
index 6aa5161b08..87b8e5131b 100644
--- a/erts/emulator/beam/erl_port_task.c
+++ b/erts/emulator/beam/erl_port_task.c
@@ -711,23 +711,6 @@ typedef struct {
     int *resp;
 } ErtsPortTaskExeBlockData;
 
-static void
-prepare_for_block(void *vd)
-{
-    ErtsPortTaskExeBlockData *d = (ErtsPortTaskExeBlockData *) vd;
-    erts_smp_runq_unlock(d->runq);
-}
-
-static void
-resume_after_block(void *vd)
-{
-    ErtsPortTaskExeBlockData *d = (ErtsPortTaskExeBlockData *) vd;
-    erts_smp_runq_lock(d->runq);
-    if (d->resp)
-	*d->resp = (erts_smp_atomic_read_nob(&erts_port_task_outstanding_io_tasks)
-		    != (erts_aint_t) 0);
-}
-
 /*
  * Run all scheduled tasks for the first port in run queue. If
  * new tasks appear while running reschedule port (free task is
@@ -752,11 +735,6 @@ erts_port_task_execute(ErtsRunQueue *runq, Port **curr_port_pp)
 
     ERTS_SMP_LC_ASSERT(erts_smp_lc_runq_is_locked(runq));
 
-    erts_smp_activity_begin(ERTS_ACTIVITY_IO,
-			    prepare_for_block,
-			    resume_after_block,
-			    (void *) &blk_data);
-
     ERTS_PT_CHK_PORTQ(runq);
 
     pp = pop_port(runq);
@@ -988,10 +966,6 @@ erts_port_task_execute(ErtsRunQueue *runq, Port **curr_port_pp)
 
  done:
     blk_data.resp = &res;
-    erts_smp_activity_end(ERTS_ACTIVITY_IO,
-			  prepare_for_block,
-			  resume_after_block,
-			  (void *) &blk_data);
 
     ERTS_SMP_LC_ASSERT(erts_smp_lc_runq_is_locked(runq));
 
diff --git a/erts/emulator/beam/erl_process.c b/erts/emulator/beam/erl_process.c
index 4dda17f559..f14a35bafd 100644
--- a/erts/emulator/beam/erl_process.c
+++ b/erts/emulator/beam/erl_process.c
@@ -155,7 +155,6 @@ do {									\
 static struct {
     erts_smp_mtx_t mtx;
     erts_smp_cnd_t cnd;
-    int aux_thread;
     int online;
     int curr_online;
     int wait_curr_online;
@@ -622,18 +621,6 @@ erts_psd_set_init(Process *p, ErtsProcLocks plocks, int ix, void *data)
 
 #ifdef ERTS_SMP
 
-static void
-prepare_for_block(void *vrq)
-{
-    erts_smp_runq_unlock((ErtsRunQueue *) vrq);
-}
-
-static void
-resume_after_block(void *vrq)
-{
-    erts_smp_runq_lock((ErtsRunQueue *) vrq);
-}
-
 void
 erts_sched_finish_poke(ErtsSchedulerSleepInfo *ssi, erts_aint32_t flags)
 {
@@ -641,6 +628,13 @@ erts_sched_finish_poke(ErtsSchedulerSleepInfo *ssi, erts_aint32_t flags)
     case ERTS_SSI_FLG_POLL_SLEEPING:
 	erts_sys_schedule_interrupt(1);
 	break;
+    case ERTS_SSI_FLG_POLL_SLEEPING|ERTS_SSI_FLG_TSE_SLEEPING:
+	/*
+	 * Thread progress blocking while poll sleeping; need
+	 * to signal on both...
+	 */
+	erts_sys_schedule_interrupt(1);
+	/* fall through */
     case ERTS_SSI_FLG_TSE_SLEEPING:
 	erts_tse_set(ssi->event);
 	break;
@@ -1482,11 +1476,50 @@ sched_set_sleeptype(ErtsSchedulerSleepInfo *ssi, erts_aint32_t sleep_type)
 
 
 static void
-poke_ssi(void *vssi)
+thr_prgr_wakeup(void *vssi)
 {
     erts_sched_poke((ErtsSchedulerSleepInfo *) vssi);
 }
 
+static void
+thr_prgr_prep_wait(void *vssi)
+{
+    ErtsSchedulerSleepInfo *ssi = (ErtsSchedulerSleepInfo *) vssi;
+    erts_smp_atomic32_read_bor_acqb(&ssi->flags,
+				    ERTS_SSI_FLG_SLEEPING);
+}
+
+static void
+thr_prgr_wait(void *vssi)
+{
+    ErtsSchedulerSleepInfo *ssi = (ErtsSchedulerSleepInfo *) vssi;
+    erts_aint32_t xflgs = ERTS_SSI_FLG_SLEEPING;
+
+    erts_tse_reset(ssi->event);
+
+    while (1) {
+	erts_aint32_t aflgs, nflgs;
+	nflgs = xflgs | ERTS_SSI_FLG_TSE_SLEEPING;
+	aflgs = erts_smp_atomic32_cmpxchg_acqb(&ssi->flags, nflgs, xflgs);
+	if (aflgs == xflgs) {
+	    erts_tse_wait(ssi->event);
+	    break;
+	}
+	if ((aflgs & ERTS_SSI_FLG_SLEEPING) == 0)
+	    break;
+	xflgs = aflgs;
+    }
+}
+
+static void
+thr_prgr_fin_wait(void *vssi)
+{
+    ErtsSchedulerSleepInfo *ssi = (ErtsSchedulerSleepInfo *) vssi;
+    erts_smp_atomic32_read_band_nob(&ssi->flags,
+				    ~(ERTS_SSI_FLG_SLEEPING
+				      | ERTS_SSI_FLG_TSE_SLEEPING));
+}
+
 static void init_aux_work_data(ErtsAuxWorkData *awdp, ErtsSchedulerData *esdp);
 
 static void *
@@ -1495,25 +1528,21 @@ aux_thread(void *unused)
     ErtsAuxWorkData *awdp = aux_thread_aux_work_data;
     ErtsSchedulerSleepInfo *ssi = ERTS_SCHED_SLEEP_INFO_IX(-1);
     erts_aint32_t aux_work;
-    ErtsThrPrgrWakeupCallback wake_me;
+    ErtsThrPrgrCallbacks callbacks;
     int thr_prgr_active = 1;
 
-    wake_me.wakeup = poke_ssi;
-    wake_me.arg = (void *) ssi;
+    ssi->event = erts_tse_fetch();
+
+    callbacks.arg = (void *) ssi;
+    callbacks.wakeup = thr_prgr_wakeup;
+    callbacks.prepare_wait = thr_prgr_prep_wait;
+    callbacks.wait = thr_prgr_wait;
+    callbacks.finalize_wait = thr_prgr_fin_wait;
 
-    erts_thr_progress_register_managed_thread(NULL, &wake_me, 1);
+    erts_thr_progress_register_managed_thread(NULL, &callbacks, 1);
     init_aux_work_data(awdp, NULL);
     awdp->ssi = ssi;
 
-    erts_register_blockable_thread();
-
-    ssi->event = erts_tse_fetch();
-
-    erts_smp_mtx_lock(&schdlr_sspnd.mtx);
-    schdlr_sspnd.aux_thread = 1;
-    erts_smp_cnd_signal(&schdlr_sspnd.cnd);
-    erts_smp_mtx_unlock(&schdlr_sspnd.mtx);
-
     sched_prep_spin_wait(ssi);
 
     while (1) {
@@ -1528,8 +1557,6 @@ aux_thread(void *unused)
 		erts_thr_progress_leader_update(NULL);
 	}
 
-	erts_smp_activity_begin(ERTS_ACTIVITY_WAIT, NULL, NULL, NULL);
-
 	if (!aux_work) {
 	    if (thr_prgr_active)
 		erts_thr_progress_active(NULL, thr_prgr_active = 0);
@@ -1552,8 +1579,6 @@ aux_thread(void *unused)
 	    erts_thr_progress_finalize_wait(NULL);
 	}
 
-	erts_smp_activity_end(ERTS_ACTIVITY_WAIT, NULL, NULL, NULL);
-
 	flgs = sched_prep_spin_wait(ssi);
     }
     return NULL;
@@ -1614,8 +1639,6 @@ scheduler_wait(int *fcalls, ErtsSchedulerData *esdp, ErtsRunQueue *rq)
 		    erts_thr_progress_leader_update(esdp);
 	    }
 
-	    erts_smp_activity_begin(ERTS_ACTIVITY_WAIT, NULL, NULL, NULL);
-
 	    if (aux_work)
 		flgs = erts_smp_atomic32_read_acqb(&ssi->flags);
 	    else {
@@ -1639,8 +1662,6 @@ scheduler_wait(int *fcalls, ErtsSchedulerData *esdp, ErtsRunQueue *rq)
 		erts_thr_progress_finalize_wait(esdp);
 	    }
 
-	    erts_smp_activity_end(ERTS_ACTIVITY_WAIT, NULL, NULL, NULL);
-
 	    if (!(flgs & ERTS_SSI_FLG_WAITING)) {
 		ASSERT(!(flgs & ERTS_SSI_FLG_SLEEPING));
 		break;
@@ -1659,6 +1680,9 @@ scheduler_wait(int *fcalls, ErtsSchedulerData *esdp, ErtsRunQueue *rq)
 	if (flgs & ~ERTS_SSI_FLG_SUSPENDED)
 	    erts_smp_atomic32_read_band_nob(&ssi->flags, ERTS_SSI_FLG_SUSPENDED);
 
+	if (!thr_prgr_active)
+	    erts_thr_progress_active(esdp, thr_prgr_active = 1);
+
 	erts_smp_runq_lock(rq);
 	sched_active(esdp->no, rq);
 
@@ -1765,12 +1789,12 @@ scheduler_wait(int *fcalls, ErtsSchedulerData *esdp, ErtsRunQueue *rq)
 	    goto sys_poll_aux_work;
 	}
 #ifdef ERTS_SMP
-	if (thr_prgr_active)
-	    erts_thr_progress_active(esdp, thr_prgr_active = 0);
 	flgs = sched_set_sleeptype(ssi, ERTS_SSI_FLG_POLL_SLEEPING);
 	if (!(flgs & ERTS_SSI_FLG_SLEEPING)) {
-	    if (!(flgs & ERTS_SSI_FLG_WAITING))
+	    if (!(flgs & ERTS_SSI_FLG_WAITING)) {
+		ASSERT(!(flgs & ERTS_SSI_FLG_SLEEPING));
 		goto sys_locked_woken;
+	    }
 	    erts_smp_runq_unlock(rq);
 	    flgs = sched_prep_cont_spin_wait(ssi);
 	    if (!(flgs & ERTS_SSI_FLG_WAITING)) {
@@ -1787,6 +1811,11 @@ scheduler_wait(int *fcalls, ErtsSchedulerData *esdp, ErtsRunQueue *rq)
 
 	erts_smp_runq_unlock(rq);
 
+#ifdef ERTS_SMP
+	if (thr_prgr_active)
+	    erts_thr_progress_active(esdp, thr_prgr_active = 0);
+#endif
+
 	ASSERT(!erts_port_task_have_outstanding_io_tasks());
 
 	erl_sys_schedule(0);
@@ -1804,8 +1833,15 @@ scheduler_wait(int *fcalls, ErtsSchedulerData *esdp, ErtsRunQueue *rq)
 	    goto sys_aux_work;
 
     sys_woken:
+	if (!thr_prgr_active)
+	    erts_thr_progress_active(esdp, thr_prgr_active = 1);
 	erts_smp_runq_lock(rq);
     sys_locked_woken:
+	if (!thr_prgr_active) {
+	    erts_smp_runq_unlock(rq);
+	    erts_thr_progress_active(esdp, thr_prgr_active = 1);
+	    erts_smp_runq_lock(rq);
+	}
 	clear_sys_scheduling();
 	if (flgs & ~ERTS_SSI_FLG_SUSPENDED)
 	    erts_smp_atomic32_read_band_nob(&ssi->flags, ERTS_SSI_FLG_SUSPENDED);
@@ -1813,12 +1849,7 @@ scheduler_wait(int *fcalls, ErtsSchedulerData *esdp, ErtsRunQueue *rq)
 	sched_active_sys(esdp->no, rq);
     }
 
-#ifdef ERTS_SMP
-    if (!thr_prgr_active)
-	erts_thr_progress_active(esdp, thr_prgr_active = 1);
-
     ERTS_SMP_LC_ASSERT(erts_smp_lc_runq_is_locked(rq));
-#endif
 }
 
 #ifdef ERTS_SMP
@@ -3364,7 +3395,6 @@ erts_init_scheduling(int mrq, int no_schedulers, int no_schedulers_online)
     erts_smp_cnd_init(&schdlr_sspnd.cnd);
 
     erts_smp_atomic32_init_nob(&schdlr_sspnd.changing, 0);
-    schdlr_sspnd.aux_thread = 0;
     schdlr_sspnd.online = no_schedulers_online;
     schdlr_sspnd.curr_online = no_schedulers;
     schdlr_sspnd.msb.ongoing = 0;
@@ -3558,18 +3588,6 @@ erts_get_max_no_executing_schedulers(void)
 #ifdef ERTS_SMP
 
 static void
-susp_sched_prep_block(void *unused)
-{
-    erts_smp_mtx_unlock(&schdlr_sspnd.mtx);
-}
-
-static void
-susp_sched_resume_block(void *unused)
-{
-    erts_smp_mtx_lock(&schdlr_sspnd.mtx);
-}
-
-static void
 scheduler_ix_resume_wake(Uint ix)
 {
     ErtsSchedulerSleepInfo *ssi = ERTS_SCHED_SLEEP_INFO_IX(ix);
@@ -3759,8 +3777,6 @@ suspend_scheduler(ErtsSchedulerData *esdp)
 			erts_thr_progress_leader_update(esdp);
 		}
 
-		erts_smp_activity_begin(ERTS_ACTIVITY_WAIT, NULL, NULL, NULL);
-
 		if (!aux_work) {
 		    if (thr_prgr_active)
 			erts_thr_progress_active(esdp, thr_prgr_active = 0);
@@ -3785,8 +3801,6 @@ suspend_scheduler(ErtsSchedulerData *esdp)
 		    erts_thr_progress_finalize_wait(esdp);
 		}
 
-		erts_smp_activity_end(ERTS_ACTIVITY_WAIT, NULL, NULL, NULL);
-
 		flgs = sched_prep_spin_suspended(ssi, (ERTS_SSI_FLG_WAITING
 						       | ERTS_SSI_FLG_SUSPENDED));
 		if (!(flgs & ERTS_SSI_FLG_SUSPENDED))
@@ -3796,7 +3810,6 @@ suspend_scheduler(ErtsSchedulerData *esdp)
 		    break;
 	    }
 
-
 	    erts_smp_mtx_lock(&schdlr_sspnd.mtx);
 	    changing = erts_smp_atomic32_read_nob(&schdlr_sspnd.changing);
 	}
@@ -3906,12 +3919,16 @@ erts_set_schedulers_online(Process *p,
 			   Sint new_no,
 			   Sint *old_no)
 {
-    int ix, res, no, have_unlocked_plocks;
+    ErtsSchedulerData *esdp;
+    int ix, res, no, have_unlocked_plocks, end_wait;
     erts_aint32_t changing;
 
     if (new_no < 1 || erts_no_schedulers < new_no)
 	return ERTS_SCHDLR_SSPND_EINVAL;
 
+    esdp = ERTS_PROC_GET_SCHDATA(p);
+    end_wait = 0;
+
     erts_smp_mtx_lock(&schdlr_sspnd.mtx);
 
     have_unlocked_plocks = 0;
@@ -4028,16 +4045,21 @@ erts_set_schedulers_online(Process *p,
 		}
 	    }
 
-	    erts_smp_activity_begin(ERTS_ACTIVITY_WAIT,
-				    susp_sched_prep_block,
-				    susp_sched_resume_block,
-				    NULL);
+	    if (schdlr_sspnd.curr_online != schdlr_sspnd.wait_curr_online) {
+		erts_smp_mtx_unlock(&schdlr_sspnd.mtx);
+		if (plocks && !have_unlocked_plocks) {
+		    have_unlocked_plocks = 1;
+		    erts_smp_proc_unlock(p, plocks);
+		}
+		erts_thr_progress_active(esdp, 0);
+		erts_thr_progress_prepare_wait(esdp);
+		end_wait = 1;
+		erts_smp_mtx_lock(&schdlr_sspnd.mtx);
+	    }
+
 	    while (schdlr_sspnd.curr_online != schdlr_sspnd.wait_curr_online)
 		erts_smp_cnd_wait(&schdlr_sspnd.cnd, &schdlr_sspnd.mtx);
-	    erts_smp_activity_end(ERTS_ACTIVITY_WAIT,
-				  susp_sched_prep_block,
-				  susp_sched_resume_block,
-				  NULL);
+
 	    ASSERT(res != ERTS_SCHDLR_SSPND_DONE
 		   ? (ERTS_SCHDLR_SSPND_CHNG_WAITER
 		      & erts_smp_atomic32_read_nob(&schdlr_sspnd.changing))
@@ -4045,10 +4067,15 @@ erts_set_schedulers_online(Process *p,
 		      == erts_smp_atomic32_read_nob(&schdlr_sspnd.changing)));
 	    erts_smp_atomic32_read_band_nob(&schdlr_sspnd.changing,
 					    ~ERTS_SCHDLR_SSPND_CHNG_WAITER);
+
 	}
     }
 
     erts_smp_mtx_unlock(&schdlr_sspnd.mtx);
+    if (end_wait) {
+	erts_thr_progress_finalize_wait(esdp);
+	erts_thr_progress_active(esdp, 1);
+    }
     if (have_unlocked_plocks)
 	erts_smp_proc_lock(p, plocks);
 
@@ -4133,17 +4160,38 @@ erts_block_multi_scheduling(Process *p, ErtsProcLocks plocks, int on, int all)
 		    erts_smp_mtx_unlock(&balance_info.update_mtx);
 		    erts_smp_mtx_lock(&schdlr_sspnd.mtx);
 		}
-		erts_smp_activity_begin(ERTS_ACTIVITY_WAIT,
-					susp_sched_prep_block,
-					susp_sched_resume_block,
-					NULL);
-		while (erts_smp_atomic32_read_nob(&schdlr_sspnd.active)
-		       != schdlr_sspnd.msb.wait_active)
-		    erts_smp_cnd_wait(&schdlr_sspnd.cnd, &schdlr_sspnd.mtx);
-		erts_smp_activity_end(ERTS_ACTIVITY_WAIT,
-				      susp_sched_prep_block,
-				      susp_sched_resume_block,
-				      NULL);
+
+		if (erts_smp_atomic32_read_nob(&schdlr_sspnd.active)
+		    != schdlr_sspnd.msb.wait_active) {
+		    ErtsSchedulerData *esdp;
+
+		    erts_smp_mtx_unlock(&schdlr_sspnd.mtx);
+
+		    if (plocks && !have_unlocked_plocks) {
+			have_unlocked_plocks = 1;
+			erts_smp_proc_unlock(p, plocks);
+		    }
+
+		    esdp = ERTS_PROC_GET_SCHDATA(p);
+
+		    erts_thr_progress_active(esdp, 0);
+		    erts_thr_progress_prepare_wait(esdp);
+
+		    erts_smp_mtx_lock(&schdlr_sspnd.mtx);
+
+		    while (erts_smp_atomic32_read_nob(&schdlr_sspnd.active)
+			   != schdlr_sspnd.msb.wait_active)
+			erts_smp_cnd_wait(&schdlr_sspnd.cnd,
+					  &schdlr_sspnd.mtx);
+		    
+		    erts_smp_mtx_unlock(&schdlr_sspnd.mtx);
+		    
+		    erts_thr_progress_active(esdp, 1);
+		    erts_thr_progress_finalize_wait(esdp);
+
+		    erts_smp_mtx_lock(&schdlr_sspnd.mtx);
+
+		}
 		ASSERT(res != ERTS_SCHDLR_SSPND_DONE_MSCHED_BLOCKED
 		       ? (ERTS_SCHDLR_SSPND_CHNG_WAITER
 			  & erts_smp_atomic32_read_nob(&schdlr_sspnd.changing))
@@ -4331,13 +4379,18 @@ erts_multi_scheduling_blockers(Process *p)
 static void *
 sched_thread_func(void *vesdp)
 {
-    ErtsThrPrgrWakeupCallback wake_me;
+    ErtsThrPrgrCallbacks callbacks;
     ErtsSchedulerData *esdp = vesdp;
     Uint no = esdp->no;
 #ifdef ERTS_SMP
-    wake_me.wakeup = poke_ssi;
-    wake_me.arg = (void *) esdp->ssi;
-    erts_thr_progress_register_managed_thread(esdp, &wake_me, 0);
+    ERTS_SCHED_SLEEP_INFO_IX(no - 1)->event = erts_tse_fetch();
+    callbacks.arg = (void *) esdp->ssi;
+    callbacks.wakeup = thr_prgr_wakeup;
+    callbacks.prepare_wait = thr_prgr_prep_wait;
+    callbacks.wait = thr_prgr_wait;
+    callbacks.finalize_wait = thr_prgr_fin_wait;
+
+    erts_thr_progress_register_managed_thread(esdp, &callbacks, 0);
     erts_alloc_register_scheduler(vesdp);
 #endif
 #ifdef ERTS_ENABLE_LOCK_CHECK
@@ -4356,15 +4409,18 @@ sched_thread_func(void *vesdp)
     erts_sched_init_check_cpu_bind(esdp);
 
     erts_proc_lock_prepare_proc_lock_waiter();
-    ERTS_SCHED_SLEEP_INFO_IX(no - 1)->event = erts_tse_fetch();
-
-
 #endif
-    erts_register_blockable_thread();
+
 #ifdef HIPE
     hipe_thread_signal_init();
 #endif
     erts_thread_init_float();
+
+    if (no == 1) {
+	erts_thr_progress_active(esdp, 0);
+	erts_thr_progress_prepare_wait(esdp);
+    }
+
     erts_smp_mtx_lock(&schdlr_sspnd.mtx);
 
     ASSERT(erts_smp_atomic32_read_nob(&schdlr_sspnd.changing)
@@ -4378,23 +4434,17 @@ sched_thread_func(void *vesdp)
     }
 
     if (no == 1) {
-	if (schdlr_sspnd.curr_online != schdlr_sspnd.wait_curr_online) {
-	    erts_smp_activity_begin(ERTS_ACTIVITY_WAIT,
-				    susp_sched_prep_block,
-				    susp_sched_resume_block,
-				    NULL);
-	    while (schdlr_sspnd.curr_online != schdlr_sspnd.wait_curr_online
-		   || !schdlr_sspnd.aux_thread)
-		erts_smp_cnd_wait(&schdlr_sspnd.cnd, &schdlr_sspnd.mtx);
-	    erts_smp_activity_end(ERTS_ACTIVITY_WAIT,
-				  susp_sched_prep_block,
-				  susp_sched_resume_block,
-				  NULL);
-	}
+	while (schdlr_sspnd.curr_online != schdlr_sspnd.wait_curr_online)
+	    erts_smp_cnd_wait(&schdlr_sspnd.cnd, &schdlr_sspnd.mtx);
 	ERTS_SCHDLR_SSPND_CHNG_SET(0, ERTS_SCHDLR_SSPND_CHNG_WAITER);
     }
     erts_smp_mtx_unlock(&schdlr_sspnd.mtx);
 
+    if (no == 1) {
+	erts_thr_progress_finalize_wait(esdp);
+	erts_thr_progress_active(esdp, 1);
+    }
+
 #ifdef ERTS_DO_VERIFY_UNUSED_TEMP_ALLOC
     esdp->verify_unused_temp_alloc
 	= erts_alloc_get_verify_unused_temp_alloc(
@@ -4431,12 +4481,6 @@ erts_start_schedulers(void)
 	res = ENOTSUP;
     }
 
-    erts_block_system(0);
-
-    res = ethr_thr_create(&aux_tid, aux_thread, NULL, &opts);
-    if (res != 0)
-	erl_exit(1, "Failed to create aux thread\n");
-
     while (actual < wanted) {
 	ErtsSchedulerData *esdp = ERTS_SCHEDULER_IX(actual);
 	actual++;
@@ -4449,7 +4493,12 @@ erts_start_schedulers(void)
     }
     
     erts_no_schedulers = actual;
-    erts_release_system();
+
+    ERTS_THR_MEMORY_BARRIER;
+
+    res = ethr_thr_create(&aux_tid, aux_thread, NULL, &opts);
+    if (res != 0)
+	erl_exit(1, "Failed to create aux thread\n");
 
     if (actual < 1)
 	erl_exit(1,
@@ -5810,7 +5859,7 @@ Process *schedule(Process *p, int calls)
 	input_reductions = INPUT_REDUCTIONS;
     }
 
-    ERTS_SMP_LC_ASSERT(!ERTS_LC_IS_BLOCKING);
+    ERTS_SMP_LC_ASSERT(!erts_thr_progress_is_blocking());
 
     /*
      * Clean up after the process being scheduled out.
@@ -5948,7 +5997,8 @@ Process *schedule(Process *p, int calls)
 
     }
 
-    ERTS_SMP_LC_ASSERT(!ERTS_LC_IS_BLOCKING);
+    ERTS_SMP_LC_ASSERT(!erts_thr_progress_is_blocking());
+
  check_activities_to_run: {
 
 #ifdef ERTS_SMP
@@ -5958,7 +6008,7 @@ Process *schedule(Process *p, int calls)
 	    check_balance(rq);
 	}
 
-	ERTS_SMP_LC_ASSERT(!ERTS_LC_IS_BLOCKING);
+	ERTS_SMP_LC_ASSERT(!erts_thr_progress_is_blocking());
 	ERTS_SMP_LC_ASSERT(erts_smp_lc_runq_is_locked(rq));
 
 	if (rq->flags & ERTS_RUNQ_FLGS_IMMIGRATE_QMASK)
@@ -5996,11 +6046,7 @@ Process *schedule(Process *p, int calls)
 	    }
 	}
 
-	erts_smp_chk_system_block(prepare_for_block,
-				  resume_after_block,
-				  (void *) rq);
-
-	ERTS_SMP_LC_ASSERT(!ERTS_LC_IS_BLOCKING);
+	ERTS_SMP_LC_ASSERT(!erts_thr_progress_is_blocking());
 	ERTS_SMP_LC_ASSERT(erts_smp_lc_runq_is_locked(rq));
 
 #else /* ERTS_SMP */
@@ -6327,14 +6373,14 @@ erts_sched_stat_modify(int what)
     int ix;
     switch (what) {
     case ERTS_SCHED_STAT_MODIFY_ENABLE:
-	erts_smp_block_system(0);
+	erts_smp_thr_progress_block();
 	erts_sched_stat.enabled = 1;
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	break;
     case ERTS_SCHED_STAT_MODIFY_DISABLE:
-	erts_smp_block_system(0);
+	erts_smp_thr_progress_block();
 	erts_sched_stat.enabled = 1;
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	break;
     case ERTS_SCHED_STAT_MODIFY_CLEAR:
 	erts_smp_spin_lock(&erts_sched_stat.lock);
@@ -6489,7 +6535,7 @@ erts_get_exact_total_reductions(Process *c_p, Uint *redsp, Uint *diffp)
      * Wait for other schedulers to schedule out their processes
      * and update 'reductions'.
      */
-    erts_smp_block_system(0);
+    erts_smp_thr_progress_block();
     for (reds = 0, ix = 0; ix < erts_no_run_queues; ix++)
 	reds += ERTS_RUNQ_IX(ix)->procs.reductions;
     if (redsp)
@@ -6497,7 +6543,7 @@ erts_get_exact_total_reductions(Process *c_p, Uint *redsp, Uint *diffp)
     if (diffp)
 	*diffp = reds - last_exact_reductions;
     last_exact_reductions = reds;
-    erts_smp_release_system();
+    erts_smp_thr_progress_unblock();
     erts_smp_proc_lock(c_p, ERTS_PROC_LOCK_MAIN);
 }
 
@@ -9302,6 +9348,22 @@ init_processes_bif(void)
  * Debug stuff
  */
 
+#if defined(ERTS_SMP) && defined(ERTS_ENABLE_LOCK_CHECK)
+int
+erts_dbg_check_halloc_lock(Process *p)
+{
+    if (ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks(p))
+	return 1;
+    if (p->id == ERTS_INVALID_PID)
+	return 1;
+    if (p->scheduler_data && p == p->scheduler_data->match_pseudo_process)
+	return 1;
+    if (erts_thr_progress_is_blocking())
+	return 1;
+    return 0;
+}
+#endif
+
 Eterm
 erts_debug_processes(Process *c_p)
 {
diff --git a/erts/emulator/beam/erl_process.h b/erts/emulator/beam/erl_process.h
index 43593f32d9..337990a0db 100644
--- a/erts/emulator/beam/erl_process.h
+++ b/erts/emulator/beam/erl_process.h
@@ -1072,6 +1072,9 @@ int erts_proclist_same(ErtsProcList *, Process *);
 
 int erts_sched_set_wakeup_limit(char *str);
 
+#if defined(ERTS_SMP) && defined(ERTS_ENABLE_LOCK_CHECK)
+int erts_dbg_check_halloc_lock(Process *p);
+#endif
 #ifdef DEBUG
 void erts_dbg_multi_scheduling_return_trap(Process *, Eterm);
 #endif
@@ -1252,16 +1255,11 @@ erts_psd_get(Process *p, int ix)
 #if defined(ERTS_SMP) && defined(ERTS_ENABLE_LOCK_CHECK)
     ErtsProcLocks locks = erts_proc_lc_my_proc_locks(p);
     if (ERTS_LC_PSD_ANY_LOCK == erts_psd_required_locks[ix].get_locks)
-	ERTS_SMP_LC_ASSERT(locks
-			   || erts_is_system_blocked(0)
-			   || (ERTS_IS_CRASH_DUMPING
-			       && erts_is_system_blocked(ERTS_BS_FLG_ALLOW_GC)));
+	ERTS_SMP_LC_ASSERT(locks || erts_thr_progress_is_blocking());
     else {
 	locks &= erts_psd_required_locks[ix].get_locks;
 	ERTS_SMP_LC_ASSERT(erts_psd_required_locks[ix].get_locks == locks
-			   || erts_is_system_blocked(0)
-			   || (ERTS_IS_CRASH_DUMPING
-			       && erts_is_system_blocked(ERTS_BS_FLG_ALLOW_GC)));
+			   || erts_thr_progress_is_blocking());
     }
 #endif
     ASSERT(0 <= ix && ix < ERTS_PSD_SIZE);
@@ -1278,16 +1276,11 @@ erts_psd_set(Process *p, ErtsProcLocks plocks, int ix, void *data)
 #if defined(ERTS_SMP) && defined(ERTS_ENABLE_LOCK_CHECK)
     ErtsProcLocks locks = erts_proc_lc_my_proc_locks(p);
     if (ERTS_LC_PSD_ANY_LOCK == erts_psd_required_locks[ix].set_locks)
-	ERTS_SMP_LC_ASSERT(locks
-			   || erts_is_system_blocked(0)
-			   || (ERTS_IS_CRASH_DUMPING
-			       && erts_is_system_blocked(ERTS_BS_FLG_ALLOW_GC)));
+	ERTS_SMP_LC_ASSERT(locks || erts_thr_progress_is_blocking());
     else {
 	locks &= erts_psd_required_locks[ix].set_locks;
 	ERTS_SMP_LC_ASSERT(erts_psd_required_locks[ix].set_locks == locks
-			   || erts_is_system_blocked(0)
-			   || (ERTS_IS_CRASH_DUMPING
-			       && erts_is_system_blocked(ERTS_BS_FLG_ALLOW_GC)));
+			   || erts_thr_progress_is_blocking());
     }
 #endif
     ASSERT(0 <= ix && ix < ERTS_PSD_SIZE);
@@ -1634,8 +1627,6 @@ erts_sched_poke(ErtsSchedulerSleepInfo *ssi)
     erts_aint32_t flags;
     ERTS_THR_MEMORY_BARRIER;
     flags = erts_smp_atomic32_read_nob(&ssi->flags);
-    ASSERT(!(flags & ERTS_SSI_FLG_SLEEPING)
-	   || (flags & ERTS_SSI_FLG_WAITING));
     if (flags & ERTS_SSI_FLG_SLEEPING) {
 	flags = erts_smp_atomic32_read_band_nob(&ssi->flags, ~ERTS_SSI_FLGS_SLEEP);
 	erts_sched_finish_poke(ssi, flags);
diff --git a/erts/emulator/beam/erl_thr_progress.c b/erts/emulator/beam/erl_thr_progress.c
index f96ae4b70d..9324bcde51 100644
--- a/erts/emulator/beam/erl_thr_progress.c
+++ b/erts/emulator/beam/erl_thr_progress.c
@@ -76,6 +76,7 @@
 
 #include <stddef.h> /* offsetof() */
 #include "erl_thr_progress.h"
+#include "global.h"
 
 #ifdef ERTS_SMP
 
@@ -88,9 +89,14 @@
 
 #define ERTS_THR_PRGR_PRINT_LEADER 0
 #define ERTS_THR_PRGR_PRINT_VAL 0
+#define ERTS_THR_PRGR_PRINT_BLOCKERS 0
 
-#define ERTS_THR_PRGR_LFLG_NO_LEADER (((erts_aint32_t) 1) << 31)
-#define ERTS_THR_PRGR_LFLG_ACTIVE_MASK (~ERTS_THR_PRGR_LFLG_NO_LEADER)
+#define ERTS_THR_PRGR_FTL_ERR_BLCK_POLL_INTERVAL 100
+
+#define ERTS_THR_PRGR_LFLG_BLOCK	(((erts_aint32_t) 1) << 31)
+#define ERTS_THR_PRGR_LFLG_NO_LEADER	(((erts_aint32_t) 1) << 30)
+#define ERTS_THR_PRGR_LFLG_ACTIVE_MASK	(~(ERTS_THR_PRGR_LFLG_NO_LEADER \
+					   | ERTS_THR_PRGR_LFLG_BLOCK))
 
 #define ERTS_THR_PRGR_LFLGS_ACTIVE(LFLGS) \
     ((LFLGS) & ERTS_THR_PRGR_LFLG_ACTIVE_MASK)
@@ -225,6 +231,11 @@ do {											\
 
 #endif /* ERTS_THR_PROGRESS_STATE_DEBUG */
 
+#define ERTS_THR_PRGR_BLCKR_INVALID (~((erts_aint32_t) 0))
+#define ERTS_THR_PRGR_BLCKR_UNMANAGED (((erts_aint32_t) 1) << 31)
+
+#define ERTS_THR_PRGR_BC_FLG_NOT_BLOCKING (((erts_aint32_t) 1) << 31)
+
 #define ERTS_THR_PRGR_BM_BITS 32
 #define ERTS_THR_PRGR_BM_SHIFT 5
 #define ERTS_THR_PRGR_BM_MASK 0x1f
@@ -249,11 +260,13 @@ typedef struct {
 
 typedef struct {
     erts_atomic32_t lflgs;
-
+    erts_atomic32_t block_count;
+    erts_atomic_t blocker_event;
     erts_atomic32_t pref_wakeup_used;
+    erts_atomic32_t managed_count;
     erts_atomic32_t managed_id;
     erts_atomic32_t unmanaged_id;    
-} ErtsThrPrgrMiscVolatile;
+} ErtsThrPrgrMiscData;
 
 typedef struct {
     ERTS_THR_PRGR_ATOMIC current;
@@ -269,19 +282,19 @@ typedef union {
 
 typedef struct {
     union {
-	ErtsThrPrgrMiscVolatile tile;
+	ErtsThrPrgrMiscData data;
 	char align__[ERTS_ALC_CACHE_LINE_ALIGN_SIZE(
-		sizeof(ErtsThrPrgrMiscVolatile))];
-    } vola;
+		sizeof(ErtsThrPrgrMiscData))];
+    } misc;
     ErtsThrPrgrArray *thr;
     struct {
 	int no;
-	ErtsThrPrgrWakeupCallback *callback;
+	ErtsThrPrgrCallbacks *callbacks;
 	ErtsThrPrgrManagedWakeupData *data[ERTS_THR_PRGR_WAKEUP_DATA_SIZE];
     } managed;
     struct {
 	int no;
-	ErtsThrPrgrWakeupCallback *callback;
+	ErtsThrPrgrCallbacks *callbacks;
 	ErtsThrPrgrUnmanagedWakeupData *data[ERTS_THR_PRGR_WAKEUP_DATA_SIZE];
     } unmanaged;
 } ErtsThrPrgrInternalData;
@@ -294,36 +307,106 @@ erts_tsd_key_t erts_thr_prgr_data_key__;
 
 static void handle_wakeup_requests(ErtsThrPrgrVal current);
 static int got_sched_wakeups(void);
+static erts_aint32_t block_thread(ErtsThrPrgrData *tpd);
 
 static ERTS_INLINE void
 wakeup_managed(int id)
 {
-    ErtsThrPrgrWakeupCallback *wdp = &intrnl->managed.callback[id];
+    ErtsThrPrgrCallbacks *cbp = &intrnl->managed.callbacks[id];
     ASSERT(0 <= id && id < intrnl->managed.no);
-    wdp->wakeup(wdp->arg);
+    cbp->wakeup(cbp->arg);
 }
 
 
 static ERTS_INLINE void
 wakeup_unmanaged(int id)
 {
-    ErtsThrPrgrWakeupCallback *wdp = &intrnl->unmanaged.callback[id];
+    ErtsThrPrgrCallbacks *cbp = &intrnl->unmanaged.callbacks[id];
     ASSERT(0 <= id && id < intrnl->unmanaged.no);
-    wdp->wakeup(wdp->arg);
+    cbp->wakeup(cbp->arg);
 }
 
 static ERTS_INLINE ErtsThrPrgrData *
-thr_prgr_data(ErtsSchedulerData *esdp)
+perhaps_thr_prgr_data(ErtsSchedulerData *esdp)
 {
-    ErtsThrPrgrData *tpd;
     if (esdp)
-	tpd = &esdp->thr_progress_data;
+	return &esdp->thr_progress_data;
     else
-	tpd = erts_tsd_get(erts_thr_prgr_data_key__);
+	return erts_tsd_get(erts_thr_prgr_data_key__);
+}
+
+static ERTS_INLINE ErtsThrPrgrData *
+thr_prgr_data(ErtsSchedulerData *esdp)
+{
+    ErtsThrPrgrData *tpd = perhaps_thr_prgr_data(esdp);
     ASSERT(tpd);
     return tpd;
 }
 
+static void
+init_tmp_thr_prgr_data(ErtsThrPrgrData *tpd)
+{
+    tpd->id = -1;
+    tpd->is_managed = 0;
+    tpd->is_blocking = 0;
+    tpd->is_temporary = 1;
+
+    erts_tsd_set(erts_thr_prgr_data_key__, (void *) tpd);
+}
+
+static ERTS_INLINE ErtsThrPrgrData *
+tmp_thr_prgr_data(ErtsSchedulerData *esdp)
+{
+    ErtsThrPrgrData *tpd = perhaps_thr_prgr_data(esdp);
+
+    if (!tpd) {
+	/*
+	 * We only allocate the part up to the wakeup_request field
+	 * which is the first field only used by registered threads
+	 */
+	tpd = erts_alloc(ERTS_ALC_T_T_THR_PRGR_DATA,
+			 offsetof(ErtsThrPrgrData, wakeup_request));
+	init_tmp_thr_prgr_data(tpd);
+    }
+
+    return tpd;
+}
+
+static ERTS_INLINE void
+return_tmp_thr_prgr_data(ErtsThrPrgrData *tpd)
+{
+    if (tpd->is_temporary) {
+	erts_tsd_set(erts_thr_prgr_data_key__, NULL);
+	erts_free(ERTS_ALC_T_T_THR_PRGR_DATA, tpd);
+    }
+}
+
+static ERTS_INLINE int
+block_count_dec(void)
+{
+    erts_aint32_t block_count;
+    block_count = erts_atomic32_dec_read_mb(&intrnl->misc.data.block_count);
+    if (block_count == 0) {
+	erts_tse_t *event;
+	event = ((erts_tse_t*)
+		 erts_atomic_read_nob(&intrnl->misc.data.blocker_event));
+	if (event)
+	    erts_tse_set(event);
+	return 1;
+    }
+
+    return (block_count & ERTS_THR_PRGR_BC_FLG_NOT_BLOCKING) == 0;
+}
+
+static ERTS_INLINE int
+block_count_inc(void)
+{
+    erts_aint32_t block_count;
+    block_count = erts_atomic32_inc_read_mb(&intrnl->misc.data.block_count);
+    return (block_count & ERTS_THR_PRGR_BC_FLG_NOT_BLOCKING) == 0;
+}
+
+
 void
 erts_thr_progress_pre_init(void)
 {
@@ -343,7 +426,7 @@ erts_thr_progress_init(int no_schedulers, int managed, int unmanaged)
     intrnl_sz = sizeof(ErtsThrPrgrInternalData);
     intrnl_sz = ERTS_ALC_CACHE_LINE_ALIGN_SIZE(intrnl_sz);
 
-    cb_sz = sizeof(ErtsThrPrgrWakeupCallback)*(managed+unmanaged);
+    cb_sz = sizeof(ErtsThrPrgrCallbacks)*(managed+unmanaged);
     cb_sz = ERTS_ALC_CACHE_LINE_ALIGN_SIZE(cb_sz);
 
     thr_arr_sz = sizeof(ErtsThrPrgrArray)*managed;
@@ -372,31 +455,36 @@ erts_thr_progress_init(int no_schedulers, int managed, int unmanaged)
     intrnl = (ErtsThrPrgrInternalData *) ptr;
     ptr += intrnl_sz;
 
-    erts_atomic32_init_nob(&intrnl->vola.tile.lflgs,
+    erts_atomic32_init_nob(&intrnl->misc.data.lflgs,
 			   ERTS_THR_PRGR_LFLG_NO_LEADER);
-    erts_atomic32_init_nob(&intrnl->vola.tile.pref_wakeup_used, 0);
-    erts_atomic32_init_nob(&intrnl->vola.tile.managed_id, no_schedulers);
-    erts_atomic32_init_nob(&intrnl->vola.tile.unmanaged_id, -1);
+    erts_atomic32_init_nob(&intrnl->misc.data.block_count,
+			   (ERTS_THR_PRGR_BC_FLG_NOT_BLOCKING
+			    | (erts_aint32_t) managed));
+    erts_atomic_init_nob(&intrnl->misc.data.blocker_event, ERTS_AINT_NULL);
+    erts_atomic32_init_nob(&intrnl->misc.data.pref_wakeup_used, 0);
+    erts_atomic32_init_nob(&intrnl->misc.data.managed_count, 0);
+    erts_atomic32_init_nob(&intrnl->misc.data.managed_id, no_schedulers);
+    erts_atomic32_init_nob(&intrnl->misc.data.unmanaged_id, -1);
 
     intrnl->thr = (ErtsThrPrgrArray *) ptr;
     ptr += thr_arr_sz;
     for (i = 0; i < managed; i++)
 	init_nob(&intrnl->thr[i].data.current, 0);
 
-    intrnl->managed.callback = (ErtsThrPrgrWakeupCallback *) ptr;
-    intrnl->unmanaged.callback = &intrnl->managed.callback[managed];
+    intrnl->managed.callbacks = (ErtsThrPrgrCallbacks *) ptr;
+    intrnl->unmanaged.callbacks = &intrnl->managed.callbacks[managed];
     ptr += cb_sz;
 
     intrnl->managed.no = managed;
     for (i = 0; i < managed; i++) {
-	intrnl->managed.callback[i].arg = NULL;
-	intrnl->managed.callback[i].wakeup = NULL;
+	intrnl->managed.callbacks[i].arg = NULL;
+	intrnl->managed.callbacks[i].wakeup = NULL;
     }
 
     intrnl->unmanaged.no = unmanaged;
     for (i = 0; i < unmanaged; i++) {
-	intrnl->unmanaged.callback[i].arg = NULL;
-	intrnl->unmanaged.callback[i].wakeup = NULL;
+	intrnl->unmanaged.callbacks[i].arg = NULL;
+	intrnl->unmanaged.callbacks[i].wakeup = NULL;
     }
 
     for (i = 0; i < ERTS_THR_PRGR_WAKEUP_DATA_SIZE; i++) {
@@ -439,21 +527,30 @@ init_wakeup_request_array(ErtsThrPrgrVal *w)
 }
 
 void
-erts_thr_progress_register_unmanaged_thread(ErtsThrPrgrWakeupCallback *callback)
+erts_thr_progress_register_unmanaged_thread(ErtsThrPrgrCallbacks *callbacks)
 {
-    ErtsThrPrgrData *tpd;
-    if (erts_tsd_get(erts_thr_prgr_data_key__))
-	erl_exit(ERTS_ABORT_EXIT,
-		 "%s:%d:%s(): Double register of thread\n",
-		 __FILE__, __LINE__, __func__);
+    ErtsThrPrgrData *tpd = perhaps_thr_prgr_data(NULL);
+    int is_blocking = 0;
+
+    if (tpd) {
+	if (!tpd->is_temporary)
+	    erl_exit(ERTS_ABORT_EXIT,
+		     "%s:%d:%s(): Double register of thread\n",
+		     __FILE__, __LINE__, __func__);
+	is_blocking = tpd->is_blocking;
+	return_tmp_thr_prgr_data(tpd);
+    }
+
     /*
      * We only allocate the part up to the leader field
      * which is the first field only used by managed threads
      */
     tpd = erts_alloc(ERTS_ALC_T_THR_PRGR_DATA,
 		     offsetof(ErtsThrPrgrData, leader));
-    tpd->id = (int) erts_atomic32_inc_read_nob(&intrnl->vola.tile.unmanaged_id);
+    tpd->id = (int) erts_atomic32_inc_read_nob(&intrnl->misc.data.unmanaged_id);
     tpd->is_managed = 0;
+    tpd->is_blocking = is_blocking;
+    tpd->is_temporary = 0;
     ASSERT(tpd->id >= 0);
     if (tpd->id >= intrnl->unmanaged.no)
 	erl_exit(ERTS_ABORT_EXIT,
@@ -463,32 +560,41 @@ erts_thr_progress_register_unmanaged_thread(ErtsThrPrgrWakeupCallback *callback)
     init_wakeup_request_array(&tpd->wakeup_request[0]);
     erts_tsd_set(erts_thr_prgr_data_key__, (void *) tpd);
 
-    intrnl->unmanaged.callback[tpd->id] = *callback;
+    ASSERT(callbacks->wakeup);
+
+    intrnl->unmanaged.callbacks[tpd->id] = *callbacks;
 }
 
 
 void
 erts_thr_progress_register_managed_thread(ErtsSchedulerData *esdp,
-					  ErtsThrPrgrWakeupCallback *callback,
+					  ErtsThrPrgrCallbacks *callbacks,
 					  int pref_wakeup)
 {
-    ErtsThrPrgrData *tpd;
-    if (erts_tsd_get(erts_thr_prgr_data_key__))
-	erl_exit(ERTS_ABORT_EXIT,
-		 "%s:%d:%s(): Double register of thread\n",
-		 __FILE__, __LINE__, __func__);
+    ErtsThrPrgrData *tpd = perhaps_thr_prgr_data(NULL);
+    int is_blocking = 0, managed;
+
+    if (tpd) {
+	if (!tpd->is_temporary)
+	    erl_exit(ERTS_ABORT_EXIT,
+		     "%s:%d:%s(): Double register of thread\n",
+		     __FILE__, __LINE__, __func__);
+	is_blocking = tpd->is_blocking;
+	return_tmp_thr_prgr_data(tpd);
+    }
+
     if (esdp)
 	tpd = &esdp->thr_progress_data;
     else
 	tpd = erts_alloc(ERTS_ALC_T_THR_PRGR_DATA, sizeof(ErtsThrPrgrData));
 
     if (pref_wakeup
-	&& !erts_atomic32_xchg_nob(&intrnl->vola.tile.pref_wakeup_used, 1))
+	&& !erts_atomic32_xchg_nob(&intrnl->misc.data.pref_wakeup_used, 1))
 	tpd->id = 0;
     else if (esdp)
 	tpd->id = (int) esdp->no;
     else
-	tpd->id = erts_atomic32_inc_read_nob(&intrnl->vola.tile.managed_id);
+	tpd->id = erts_atomic32_inc_read_nob(&intrnl->misc.data.managed_id);
     ASSERT(tpd->id >= 0);
     if (tpd->id >= intrnl->managed.no)
 	erl_exit(ERTS_ABORT_EXIT,
@@ -496,6 +602,8 @@ erts_thr_progress_register_managed_thread(ErtsSchedulerData *esdp,
 		 __FILE__, __LINE__, __func__);
 
     tpd->is_managed = 1;
+    tpd->is_blocking = is_blocking;
+    tpd->is_temporary = 0;
 
     init_wakeup_request_array(&tpd->wakeup_request[0]);
 
@@ -507,14 +615,46 @@ erts_thr_progress_register_managed_thread(ErtsSchedulerData *esdp,
     tpd->previous.current = ERTS_THR_PRGR_VAL_WAITING;
     erts_tsd_set(erts_thr_prgr_data_key__, (void *) tpd);
 
-    erts_atomic32_inc_nob(&intrnl->vola.tile.lflgs);
-    intrnl->managed.callback[tpd->id] = *callback;
+    erts_atomic32_inc_nob(&intrnl->misc.data.lflgs);
+
+    ASSERT(callbacks->wakeup);
+    ASSERT(callbacks->prepare_wait);
+    ASSERT(callbacks->wait);
+    ASSERT(callbacks->finalize_wait);
+
+    intrnl->managed.callbacks[tpd->id] = *callbacks;
+
+    callbacks->prepare_wait(callbacks->arg);
+    managed = erts_atomic32_inc_read_relb(&intrnl->misc.data.managed_count);
+    if (managed != intrnl->managed.no) {
+	/* Wait until all managed threads have registered... */
+	do {
+	    callbacks->wait(callbacks->arg);
+	    callbacks->prepare_wait(callbacks->arg);
+	    managed = erts_atomic32_read_acqb(&intrnl->misc.data.managed_count);
+	} while (managed != intrnl->managed.no);
+    }
+    else {
+	int id;
+	/* All managed threads have registered; lets go... */
+	for (id = 0; id < managed; id++)
+	    if (id != tpd->id)
+		wakeup_managed(id);
+    }
+    callbacks->finalize_wait(callbacks->arg);
 }
 
 static ERTS_INLINE int
 leader_update(ErtsThrPrgrData *tpd)
 {
-    if (tpd->leader) {
+#ifdef ERTS_ENABLE_LOCK_CHECK
+    erts_lc_check_exact(NULL, 0);
+#endif
+    if (!tpd->leader) {
+	/* Probably need to block... */
+	block_thread(tpd);
+    }
+    else {
 	erts_aint32_t lflgs;
 	ErtsThrPrgrVal next;
 	int ix, sz, make_progress;
@@ -570,16 +710,24 @@ leader_update(ErtsThrPrgrData *tpd)
 	    handle_wakeup_requests(current);
 	}
 
-	if (!tpd->active) {
+	if (tpd->active) {
+	    lflgs = erts_atomic32_read_nob(&intrnl->misc.data.lflgs);
+	    if (lflgs & ERTS_THR_PRGR_LFLG_BLOCK)
+		(void) block_thread(tpd);
+	}
+	else {
 	    tpd->leader = 0;
 	    tpd->previous.current = ERTS_THR_PRGR_VAL_WAITING;
 #if ERTS_THR_PRGR_PRINT_LEADER
 	    erts_fprintf(stderr, "L <- %d\n", tpd->id);
 #endif
+
 	    ERTS_THR_PROGRESS_STATE_DEBUG_SET_LEADER(tpd->id, 0);
 
-	    lflgs = erts_atomic32_read_bor_relb(&intrnl->vola.tile.lflgs,
+	    lflgs = erts_atomic32_read_bor_relb(&intrnl->misc.data.lflgs,
 						ERTS_THR_PRGR_LFLG_NO_LEADER);
+	    if (lflgs & ERTS_THR_PRGR_LFLG_BLOCK)
+		lflgs = block_thread(tpd);
 	    if (ERTS_THR_PRGR_LFLGS_ACTIVE(lflgs) == 0 && got_sched_wakeups())
 		wakeup_managed(0);
 	}
@@ -591,10 +739,14 @@ leader_update(ErtsThrPrgrData *tpd)
 static int
 update(ErtsThrPrgrData *tpd)
 {
+    int res;
     ErtsThrPrgrVal val;
 
-    if (!tpd->leader) {
+    if (tpd->leader)
+	res = 1;
+    else {
 	erts_aint32_t lflgs;
+	res = 0;
 	val = read_acqb(&erts_thr_prgr__.current);
 	if (tpd->previous.local == val) {
 	    val++;
@@ -604,13 +756,16 @@ update(ErtsThrPrgrData *tpd)
 	    set_mb(&intrnl->thr[tpd->id].data.current, val);
 	}
 
-	lflgs = erts_atomic32_read_nob(&intrnl->vola.tile.lflgs);
+	lflgs = erts_atomic32_read_nob(&intrnl->misc.data.lflgs);
+	if (lflgs & ERTS_THR_PRGR_LFLG_BLOCK)
+	    res = 1; /* Need to block in leader_update() */
+
 	if ((lflgs & ERTS_THR_PRGR_LFLG_NO_LEADER)
 	    && (tpd->active || ERTS_THR_PRGR_LFLGS_ACTIVE(lflgs) == 0)) {
 	    /* Try to take over leadership... */
 	    erts_aint32_t olflgs;
 	    olflgs = erts_atomic32_read_band_acqb(
-		&intrnl->vola.tile.lflgs,
+		&intrnl->misc.data.lflgs,
 		~ERTS_THR_PRGR_LFLG_NO_LEADER);
 	    if (olflgs & ERTS_THR_PRGR_LFLG_NO_LEADER) {
 		tpd->leader = 1;
@@ -620,8 +775,9 @@ update(ErtsThrPrgrData *tpd)
 		ERTS_THR_PROGRESS_STATE_DEBUG_SET_LEADER(tpd->id, 1);
 	    }
 	}
+	res |= tpd->leader;
     }
-    return tpd->leader;
+    return res;
 }
 
 int
@@ -643,10 +799,16 @@ erts_thr_progress_prepare_wait(ErtsSchedulerData *esdp)
     erts_aint32_t lflgs;
     ErtsThrPrgrData *tpd = thr_prgr_data(esdp);
 
+#ifdef ERTS_ENABLE_LOCK_CHECK
+    erts_lc_check_exact(NULL, 0);
+#endif
+
+    block_count_dec();
+
     tpd->previous.local = ERTS_THR_PRGR_VAL_WAITING;
     set_mb(&intrnl->thr[tpd->id].data.current, ERTS_THR_PRGR_VAL_WAITING);
 
-    lflgs = erts_atomic32_read_nob(&intrnl->vola.tile.lflgs);
+    lflgs = erts_atomic32_read_nob(&intrnl->misc.data.lflgs);
     if (ERTS_THR_PRGR_LFLGS_ALL_WAITING(lflgs) && got_sched_wakeups())
 	wakeup_managed(0); /* Someone need to make progress */
 }
@@ -657,6 +819,10 @@ erts_thr_progress_finalize_wait(ErtsSchedulerData *esdp)
     ErtsThrPrgrData *tpd = thr_prgr_data(esdp);
     ErtsThrPrgrVal current, val;
 
+#ifdef ERTS_ENABLE_LOCK_CHECK
+    erts_lc_check_exact(NULL, 0);
+#endif
+
     /*
      * We aren't allowed to continue until our thread
      * progress is past global current.
@@ -673,6 +839,8 @@ erts_thr_progress_finalize_wait(ErtsSchedulerData *esdp)
 	    break;
 	current = val;
     }
+    if (block_count_inc())
+	block_thread(tpd);
     if (update(tpd))
 	leader_update(tpd);
 }
@@ -682,25 +850,28 @@ erts_thr_progress_active(ErtsSchedulerData *esdp, int on)
 {
     ErtsThrPrgrData *tpd = thr_prgr_data(esdp);
 
+#ifdef ERTS_ENABLE_LOCK_CHECK
+    erts_lc_check_exact(NULL, 0);
+#endif
+
     ERTS_THR_PROGRESS_STATE_DEBUG_SET_ACTIVE(tpd->id, on);
 
     if (on) {
 	ASSERT(!tpd->active);
 	tpd->active = 1;
-	erts_atomic32_inc_nob(&intrnl->vola.tile.lflgs);
+	erts_atomic32_inc_nob(&intrnl->misc.data.lflgs);
     }
     else {
 	ASSERT(tpd->active);
 	tpd->active = 0;
-	erts_atomic32_dec_nob(&intrnl->vola.tile.lflgs);
-
+	erts_atomic32_dec_nob(&intrnl->misc.data.lflgs);
 	if (update(tpd))
 	    leader_update(tpd);
     }
 
 #ifdef DEBUG
     {
-	erts_aint32_t n = erts_atomic32_read_nob(&intrnl->vola.tile.lflgs);
+	erts_aint32_t n = erts_atomic32_read_nob(&intrnl->misc.data.lflgs);
 	n &= ERTS_THR_PRGR_LFLG_ACTIVE_MASK;
 	ASSERT(tpd->active <= n && n <= intrnl->managed.no);
     }
@@ -868,7 +1039,7 @@ erts_thr_progress_wakeup(ErtsSchedulerData *esdp,
 			 ErtsThrPrgrVal value)
 {
     ErtsThrPrgrData *tpd = thr_prgr_data(esdp);
-    ASSERT(tpd);
+    ASSERT(!tpd->is_temporary);
     if (tpd->is_managed)
 	request_wakeup_managed(tpd, value);
     else
@@ -957,6 +1128,198 @@ got_sched_wakeups(void)
     return 0;
 }
 
+static erts_aint32_t
+block_thread(ErtsThrPrgrData *tpd)
+{
+    erts_aint32_t lflgs;
+    ErtsThrPrgrCallbacks *cbp = &intrnl->managed.callbacks[tpd->id];
+
+    do {
+	block_count_dec();
+
+	while (1) {
+	    cbp->prepare_wait(cbp->arg);
+	    lflgs = erts_atomic32_read_nob(&intrnl->misc.data.lflgs);
+	    if (lflgs & ERTS_THR_PRGR_LFLG_BLOCK)
+		cbp->wait(cbp->arg);
+	    else
+		break;
+	}
+
+    } while (block_count_inc());
+
+    cbp->finalize_wait(cbp->arg);
+
+    return lflgs;
+}
+
+static erts_aint32_t
+thr_progress_block(ErtsThrPrgrData *tpd, int wait)
+{
+    erts_tse_t *event = NULL; /* Remove erroneous warning... sigh... */
+    erts_aint32_t lflgs, bc;
+
+    if (tpd->is_blocking++)
+	return (erts_aint32_t) 0;
+
+    while (1) {
+	lflgs = erts_atomic32_read_bor_nob(&intrnl->misc.data.lflgs,
+					   ERTS_THR_PRGR_LFLG_BLOCK);
+	if (lflgs & ERTS_THR_PRGR_LFLG_BLOCK)
+	    block_thread(tpd);
+	else
+	    break;
+    }
+
+#if ERTS_THR_PRGR_PRINT_BLOCKERS
+    erts_fprintf(stderr, "block(%d)\n", tpd->id);
+#endif
+
+    ASSERT(ERTS_AINT_NULL
+	   == erts_atomic_read_nob(&intrnl->misc.data.blocker_event));
+
+    if (wait) {
+	event = erts_tse_fetch();
+	erts_tse_reset(event);
+	erts_atomic_set_nob(&intrnl->misc.data.blocker_event,
+			    (erts_aint_t) event);
+    }
+    if (tpd->is_managed)
+	erts_atomic32_dec_nob(&intrnl->misc.data.block_count);
+    bc = erts_atomic32_read_band_mb(&intrnl->misc.data.block_count,
+				    ~ERTS_THR_PRGR_BC_FLG_NOT_BLOCKING);
+    bc &= ~ERTS_THR_PRGR_BC_FLG_NOT_BLOCKING;
+    if (wait) {
+	while (bc != 0) {
+	    erts_tse_wait(event);
+	    erts_tse_reset(event);
+	    bc = erts_atomic32_read_acqb(&intrnl->misc.data.block_count);
+	}
+    }
+    return bc;
+
+}
+
+void
+erts_thr_progress_block(void)
+{
+    thr_progress_block(tmp_thr_prgr_data(NULL), 1);
+}
+
+void
+erts_thr_progress_fatal_error_block(SWord timeout)
+{
+    ErtsThrPrgrData tpd_buf;
+    ErtsThrPrgrData *tpd = perhaps_thr_prgr_data(NULL);
+    erts_aint32_t bc;
+    SWord time_left = timeout;
+    SysTimeval to;
+
+    /*
+     * Counting poll intervals may give us a too long timeout
+     * if cpu is busy. If we got tolerant time of day we use it
+     * to prevent this.
+     */
+    if (!erts_disable_tolerant_timeofday) {
+	erts_get_timeval(&to);
+	to.tv_sec += timeout / 1000;
+	to.tv_sec += timeout % 1000;
+    }
+
+    if (!tpd) {
+	/*
+	 * We stack allocate since failure to allocate memory may
+	 * have caused the problem in the first place. This is ok
+	 * since we never complete an unblock after a fatal error
+	 * block.
+	 */
+	tpd = &tpd_buf;
+	init_tmp_thr_prgr_data(tpd);
+    }
+
+    bc = thr_progress_block(tpd, 0);
+    if (bc == 0)
+	return; /* Succefully blocked all managed threads */
+
+    while (1) {
+	if (erts_milli_sleep(ERTS_THR_PRGR_FTL_ERR_BLCK_POLL_INTERVAL) == 0)
+	    time_left -= ERTS_THR_PRGR_FTL_ERR_BLCK_POLL_INTERVAL;
+	bc = erts_atomic32_read_acqb(&intrnl->misc.data.block_count);
+	if (bc == 0)
+	    break; /* Succefully blocked all managed threads */
+	if (time_left <= 0)
+	    break; /* Timeout */
+	if (!erts_disable_tolerant_timeofday) {
+	    SysTimeval now;
+	    erts_get_timeval(&now);
+	    if (now.tv_sec > to.tv_sec)
+		break; /* Timeout */
+	    if (now.tv_sec == to.tv_sec && now.tv_usec >= to.tv_usec)
+		break; /* Timeout */
+	}
+    }
+}
+
+void
+erts_thr_progress_unblock(void)
+{
+    erts_tse_t *event;
+    int id, break_id, sz, wakeup;
+    ErtsThrPrgrData *tpd = thr_prgr_data(NULL);
+
+    ASSERT(tpd->is_blocking);
+    if (--tpd->is_blocking)
+	return;
+
+    sz = intrnl->managed.no;
+
+    wakeup = 1;
+    if (!tpd->is_managed)
+	id = break_id = tpd->id < 0 ? 0 : tpd->id % sz;
+    else {
+	break_id = tpd->id;
+	id = break_id + 1;
+	if (id >= sz)
+	    id = 0;
+	if (id == break_id)
+	    wakeup = 0;
+	erts_atomic32_inc_nob(&intrnl->misc.data.block_count);
+    }
+
+    event = ((erts_tse_t *)
+	     erts_atomic_read_nob(&intrnl->misc.data.blocker_event));
+    ASSERT(event);
+    erts_atomic_set_nob(&intrnl->misc.data.blocker_event, ERTS_AINT_NULL);
+
+    erts_atomic32_read_bor_relb(&intrnl->misc.data.block_count,
+				ERTS_THR_PRGR_BC_FLG_NOT_BLOCKING);
+#if ERTS_THR_PRGR_PRINT_BLOCKERS
+    erts_fprintf(stderr, "unblock(%d)\n", tpd->id);
+#endif
+    erts_atomic32_read_band_mb(&intrnl->misc.data.lflgs,
+			       ~ERTS_THR_PRGR_LFLG_BLOCK);
+
+    if (wakeup) {
+	do {
+	    ErtsThrPrgrVal tmp;
+	    tmp = read_nob(&intrnl->thr[id].data.current);
+	    if (tmp != ERTS_THR_PRGR_VAL_WAITING)
+		wakeup_managed(id);
+	    if (++id >= sz)
+		id = 0;
+	} while (id != break_id);
+    }
+
+    return_tmp_thr_prgr_data(tpd);
+    erts_tse_return(event);
+}
+
+int
+erts_thr_progress_is_blocking(void)
+{
+    ErtsThrPrgrData *tpd = perhaps_thr_prgr_data(NULL);
+    return tpd && tpd->is_blocking;
+}
 
 void erts_thr_progress_dbg_print_state(void)
 {
diff --git a/erts/emulator/beam/erl_thr_progress.h b/erts/emulator/beam/erl_thr_progress.h
index 36880c10f0..68d14174b9 100644
--- a/erts/emulator/beam/erl_thr_progress.h
+++ b/erts/emulator/beam/erl_thr_progress.h
@@ -32,7 +32,22 @@
 
 #include "sys.h"
 
-#ifdef ERTS_SMP
+#ifndef ERTS_SMP
+
+#define erts_smp_thr_progress_block() ((void) 0)
+#define erts_smp_thr_progress_unblock() ((void) 0)
+#define erts_smp_thr_progress_is_blocking() 1
+
+#else /* ERTS_SMP */
+
+#define erts_smp_thr_progress_block erts_thr_progress_block
+#define erts_smp_thr_progress_unblock erts_thr_progress_unblock
+#define erts_smp_thr_progress_is_blocking erts_thr_progress_is_blocking
+
+void erts_thr_progress_fatal_error_block(SWord timeout);
+void erts_thr_progress_block(void);
+void erts_thr_progress_unblock(void);
+int erts_thr_progress_is_blocking(void);
 
 typedef Uint64 ErtsThrPrgrVal;
 
@@ -41,9 +56,14 @@ typedef Uint64 ErtsThrPrgrVal;
 typedef struct {
     int id;
     int is_managed;
+    int is_blocking;
+    int is_temporary;
+
+    /* --- Part below only for registered threads --- */
+
     ErtsThrPrgrVal wakeup_request[ERTS_THR_PRGR_WAKEUP_DATA_SIZE];
 
-    /* --- Part below only for managed threads */
+    /* --- Part below only for managed threads --- */
 
     int leader; /* Needs to be first in the managed threads part */
     int active;
@@ -77,8 +97,11 @@ extern erts_tsd_key_t erts_thr_prgr_data_key__;
 
 typedef struct {
     void *arg;
-    void (*wakeup)(void *arg);
-} ErtsThrPrgrWakeupCallback;
+    void (*wakeup)(void *);
+    void (*prepare_wait)(void *);
+    void (*wait)(void *);
+    void (*finalize_wait)(void *);
+} ErtsThrPrgrCallbacks;
 
 typedef struct {
     ERTS_THR_PRGR_ATOMIC current;
@@ -89,9 +112,9 @@ extern ErtsThrPrgr erts_thr_prgr__;
 void erts_thr_progress_pre_init(void);
 void erts_thr_progress_init(int no_schedulers, int managed, int unmanaged);
 void erts_thr_progress_register_managed_thread(ErtsSchedulerData *esdp,
-					       ErtsThrPrgrWakeupCallback *,
+					       ErtsThrPrgrCallbacks *,
 					       int);
-void erts_thr_progress_register_unmanaged_thread(ErtsThrPrgrWakeupCallback *);
+void erts_thr_progress_register_unmanaged_thread(ErtsThrPrgrCallbacks *);
 void erts_thr_progress_active(ErtsSchedulerData *esdp, int on);
 void erts_thr_progress_wakeup(ErtsSchedulerData *esdp,
 			      ErtsThrPrgrVal value);
diff --git a/erts/emulator/beam/erl_trace.c b/erts/emulator/beam/erl_trace.c
index 8833137112..ec99f76e53 100644
--- a/erts/emulator/beam/erl_trace.c
+++ b/erts/emulator/beam/erl_trace.c
@@ -36,6 +36,7 @@
 #include "error.h"
 #include "erl_binary.h"
 #include "erl_bits.h"
+#include "erl_thr_progress.h"
 
 #if 0
 #define DEBUG_PRINTOUTS
@@ -159,7 +160,7 @@ static Uint active_sched;
 void
 erts_system_profile_setup_active_schedulers(void)
 {
-    ERTS_SMP_LC_ASSERT(erts_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_thr_progress_is_blocking());
     active_sched = erts_active_schedulers();
 }
 
@@ -1940,7 +1941,8 @@ trace_proc(Process *c_p, Process *t_p, Eterm what, Eterm data)
     Eterm* hp;
     int need;
 
-    ERTS_SMP_LC_ASSERT((erts_proc_lc_my_proc_locks(t_p) != 0) || erts_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT((erts_proc_lc_my_proc_locks(t_p) != 0)
+		       || erts_thr_progress_is_blocking());
     if (is_internal_port(t_p->tracer_proc)) {
 #define LOCAL_HEAP_SIZE (5+5)
 	DeclareTmpHeapNoproc(local_heap,LOCAL_HEAP_SIZE);
@@ -2745,7 +2747,8 @@ trace_port(Port *t_p, Eterm what, Eterm data) {
     Eterm mess;
     Eterm* hp;
 
-    ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(t_p) || erts_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(t_p)
+		       || erts_thr_progress_is_blocking());
 
     if (is_internal_port(t_p->tracer_proc)) {
 #define LOCAL_HEAP_SIZE (5+5)
@@ -3021,8 +3024,6 @@ static ErtsSysMsgQ *sys_message_queue_end;
 static erts_tid_t sys_msg_dispatcher_tid;
 static erts_cnd_t smq_cnd;
 
-static int dispatcher_waiting;
-
 ERTS_QUALLOC_IMPL(smq_element, ErtsSysMsgQ, 20, ERTS_ALC_T_SYS_MSG_Q)
 
 static void
@@ -3066,18 +3067,6 @@ enqueue_sys_msg(enum ErtsSysMsgType type,
     erts_smp_mtx_unlock(&smq_mtx);
 }
 
-static void
-prepare_for_block(void *unused)
-{
-    erts_smp_mtx_unlock(&smq_mtx);
-}
-
-static void
-resume_after_block(void *unused)
-{
-    erts_smp_mtx_lock(&smq_mtx);
-}
-
 void
 erts_queue_error_logger_message(Eterm from, Eterm msg, ErlHeapFragment *bp)
 {
@@ -3143,10 +3132,10 @@ sys_msg_disp_failure(ErtsSysMsgQ *smqp, Eterm receiver)
 	    && !erts_system_monitor_flags.busy_port
 	    && !erts_system_monitor_flags.busy_dist_port)
 	    break; /* Everything is disabled */
-	erts_smp_block_system(ERTS_BS_FLG_ALLOW_GC);
+	erts_smp_thr_progress_block();
 	if (system_monitor == receiver || receiver == NIL)
 	    erts_system_monitor_clear(NULL);
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	break;
 	 case SYS_MSG_TYPE_SYSPROF:
 	if (receiver == NIL
@@ -3156,11 +3145,11 @@ sys_msg_disp_failure(ErtsSysMsgQ *smqp, Eterm receiver)
 	    && !erts_system_profile_flags.scheduler)
 		 break;
 	/* Block system to clear flags */
-	erts_smp_block_system(0);
+	erts_smp_thr_progress_block();
 	if (system_profile == receiver || receiver == NIL) { 
 		erts_system_profile_clear(NULL);
 	}
-	erts_smp_release_system();
+	erts_smp_thr_progress_unblock();
 	break;
     case SYS_MSG_TYPE_ERRLGR: {
 	char *no_elgger = "(no error logger present)";
@@ -3201,22 +3190,68 @@ sys_msg_disp_failure(ErtsSysMsgQ *smqp, Eterm receiver)
     }
 }
 
+static void
+sys_msg_dispatcher_wakeup(void *vwait_p)
+{
+    int *wait_p = (int *) vwait_p;
+    erts_smp_mtx_lock(&smq_mtx);
+    *wait_p = 0;
+    erts_smp_cnd_signal(&smq_cnd);
+    erts_smp_mtx_unlock(&smq_mtx);
+}
+
+static void
+sys_msg_dispatcher_prep_wait(void *vwait_p)
+{
+    int *wait_p = (int *) vwait_p;
+    erts_smp_mtx_lock(&smq_mtx);
+    *wait_p = 1;
+    erts_smp_mtx_unlock(&smq_mtx);
+}
+
+static void
+sys_msg_dispatcher_fin_wait(void *vwait_p)
+{
+    int *wait_p = (int *) vwait_p;
+    erts_smp_mtx_lock(&smq_mtx);
+    *wait_p = 0;
+    erts_smp_mtx_unlock(&smq_mtx);
+}
+
+static void
+sys_msg_dispatcher_wait(void *vwait_p)
+{
+    int *wait_p = (int *) vwait_p;
+    erts_smp_mtx_lock(&smq_mtx);
+    while (*wait_p)
+	erts_smp_cnd_wait(&smq_cnd, &smq_mtx);
+    erts_smp_mtx_unlock(&smq_mtx);
+}
+
 static void *
 sys_msg_dispatcher_func(void *unused)
 {
+    ErtsThrPrgrCallbacks callbacks;
     ErtsSysMsgQ *local_sys_message_queue = NULL;
+    int wait = 0;
 
 #ifdef ERTS_ENABLE_LOCK_CHECK
     erts_lc_set_thread_name("system message dispatcher");
 #endif
 
-    erts_register_blockable_thread();
-    erts_smp_activity_begin(ERTS_ACTIVITY_IO, NULL, NULL, NULL);
+    callbacks.arg = (void *) &wait;
+    callbacks.wakeup = sys_msg_dispatcher_wakeup;
+    callbacks.prepare_wait = sys_msg_dispatcher_prep_wait;
+    callbacks.wait = sys_msg_dispatcher_wait;
+    callbacks.finalize_wait = sys_msg_dispatcher_fin_wait;
+
+    erts_thr_progress_register_managed_thread(NULL, &callbacks, 0);
 
     while (1) {
+	int end_wait = 0;
 	ErtsSysMsgQ *smqp;
 
-	ERTS_SMP_LC_ASSERT(!ERTS_LC_IS_BLOCKING);
+	ERTS_SMP_LC_ASSERT(!erts_thr_progress_is_blocking());
 
 	erts_smp_mtx_lock(&smq_mtx);
 
@@ -3228,20 +3263,16 @@ sys_msg_dispatcher_func(void *unused)
 	}
 
 	/* Fetch current trace message queue ... */
-	erts_smp_activity_change(ERTS_ACTIVITY_IO,
-				 ERTS_ACTIVITY_WAIT,
-				 prepare_for_block,
-				 resume_after_block,
-				 NULL);
-	dispatcher_waiting = 1;
+	if (!sys_message_queue) {
+	    erts_smp_mtx_unlock(&smq_mtx);
+	    end_wait = 1;
+	    erts_thr_progress_active(NULL, 0);
+	    erts_thr_progress_prepare_wait(NULL);
+	    erts_smp_mtx_lock(&smq_mtx);
+	}
+
 	while (!sys_message_queue)
 	    erts_smp_cnd_wait(&smq_cnd, &smq_mtx);
-	dispatcher_waiting = 0;
-	erts_smp_activity_change(ERTS_ACTIVITY_WAIT,
-				 ERTS_ACTIVITY_IO,
-				 prepare_for_block,
-				 resume_after_block,
-				 NULL);
 
 	local_sys_message_queue = sys_message_queue;
 	sys_message_queue = NULL;
@@ -3249,6 +3280,11 @@ sys_msg_dispatcher_func(void *unused)
 
 	erts_smp_mtx_unlock(&smq_mtx);
 
+	if (end_wait) {
+	    erts_thr_progress_finalize_wait(NULL);
+	    erts_thr_progress_active(NULL, 1);
+	}
+
 	/* Send trace messages ... */
 
 	ASSERT(local_sys_message_queue);
@@ -3259,6 +3295,9 @@ sys_msg_dispatcher_func(void *unused)
 	    Process *proc = NULL;
 	    Port *port = NULL;
 
+	    if (erts_thr_progress_update(NULL))
+		erts_thr_progress_leader_update(NULL);
+
 #ifdef DEBUG_PRINTOUTS
 	    print_msg_type(smqp);
 #endif
@@ -3372,7 +3411,6 @@ sys_msg_dispatcher_func(void *unused)
 	}
     }
 
-    erts_smp_activity_end(ERTS_ACTIVITY_IO, NULL, NULL, NULL);
     return NULL;
 }
 
@@ -3422,7 +3460,6 @@ init_sys_msg_dispatcher(void)
     sys_message_queue_end = NULL;
     erts_smp_cnd_init(&smq_cnd);
     erts_smp_mtx_init(&smq_mtx, "sys_msg_q");
-    dispatcher_waiting = 0;
     erts_smp_thr_create(&sys_msg_dispatcher_tid,
 			sys_msg_dispatcher_func,
 			NULL,
diff --git a/erts/emulator/beam/erl_vm.h b/erts/emulator/beam/erl_vm.h
index e7fd144ec3..0b07e894cf 100644
--- a/erts/emulator/beam/erl_vm.h
+++ b/erts/emulator/beam/erl_vm.h
@@ -83,11 +83,7 @@
 #define CP_SIZE 1
 
 #define ErtsHAllocLockCheck(P) \
-  ERTS_SMP_LC_ASSERT((ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks((P))) \
-      	             || ((P)->id == ERTS_INVALID_PID) \
-		     || ((P)->scheduler_data \
-			 && (P) == (P)->scheduler_data->match_pseudo_process) \
-		     || erts_is_system_blocked(0))
+  ERTS_SMP_LC_ASSERT(erts_dbg_check_halloc_lock((P)))
 
 
 #ifdef DEBUG
diff --git a/erts/emulator/beam/export.c b/erts/emulator/beam/export.c
index 5bc402fe22..18d62dac1d 100644
--- a/erts/emulator/beam/export.c
+++ b/erts/emulator/beam/export.c
@@ -208,7 +208,8 @@ erts_export_put(Eterm mod, Eterm func, unsigned int arity)
     Export e;
     int ix;
 
-    ERTS_SMP_LC_ASSERT(erts_initialized == 0 || erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_initialized == 0
+		       || erts_smp_thr_progress_is_blocking());
     ASSERT(is_atom(mod));
     ASSERT(is_atom(func));
     e.code[0] = mod;
@@ -265,7 +266,8 @@ erts_export_consolidate(void)
     HashInfo hi;
 #endif
 
-    ERTS_SMP_LC_ASSERT(erts_initialized == 0 || erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_initialized == 0
+		       || erts_smp_thr_progress_is_blocking());
 
     export_write_lock();
     erts_index_merge(&secondary_export_table, &export_table);
diff --git a/erts/emulator/beam/module.c b/erts/emulator/beam/module.c
index 91e4ccce70..b93b1ad09a 100644
--- a/erts/emulator/beam/module.c
+++ b/erts/emulator/beam/module.c
@@ -1,7 +1,7 @@
 /*
  * %CopyrightBegin%
  *
- * Copyright Ericsson AB 1996-2010. All Rights Reserved.
+ * Copyright Ericsson AB 1996-2011. All Rights Reserved.
  *
  * The contents of this file are subject to the Erlang Public License,
  * Version 1.1, (the "License"); you may not use this file except in
@@ -108,7 +108,8 @@ erts_put_module(Eterm mod)
     int index;
 
     ASSERT(is_atom(mod));
-    ERTS_SMP_LC_ASSERT(erts_initialized == 0 || erts_smp_is_system_blocked(0));
+    ERTS_SMP_LC_ASSERT(erts_initialized == 0
+		       || erts_smp_thr_progress_is_blocking());
     e.module = atom_val(mod);
     index = index_put(&module_table, (void*) &e);
     return (Module*) erts_index_lookup(&module_table, index);
diff --git a/erts/emulator/beam/sys.h b/erts/emulator/beam/sys.h
index 9f5747205d..b63fe98f27 100644
--- a/erts/emulator/beam/sys.h
+++ b/erts/emulator/beam/sys.h
@@ -702,283 +702,6 @@ typedef struct {
 
 void sys_alloc_stat(SysAllocStat *);
 
-/* Block the whole system... */
-
-#define ERTS_BS_FLG_ALLOW_GC				(((Uint32) 1) << 0)
-#define ERTS_BS_FLG_ALLOW_IO				(((Uint32) 1) << 1)
-
-/* Activities... */
-typedef enum {
-    ERTS_ACTIVITY_UNDEFINED,	/* Undefined activity */
-    ERTS_ACTIVITY_WAIT,		/* Waiting */
-    ERTS_ACTIVITY_GC,		/* Garbage collecting */
-    ERTS_ACTIVITY_IO		/* I/O including message passing to erl procs */
-} erts_activity_t;
-
-#ifdef ERTS_SMP
-
-typedef enum {
-    ERTS_ACT_ERR_LEAVE_WAIT_UNLOCKED,
-    ERTS_ACT_ERR_LEAVE_UNKNOWN_ACTIVITY,
-    ERTS_ACT_ERR_ENTER_UNKNOWN_ACTIVITY
-} erts_activity_error_t;
-
-typedef struct {
-    erts_smp_atomic32_t do_block;
-    struct {
-	erts_smp_atomic32_t wait;
-	erts_smp_atomic32_t gc;
-	erts_smp_atomic32_t io;
-    } in_activity;
-} erts_system_block_state_t;
-
-extern erts_system_block_state_t erts_system_block_state;
-
-int erts_is_system_blocked(erts_activity_t allowed_activities);
-void erts_block_me(void (*prepare)(void *), void (*resume)(void *), void *arg);
-void erts_register_blockable_thread(void);
-void erts_unregister_blockable_thread(void);
-void erts_note_activity_begin(erts_activity_t activity);
-void
-erts_check_block(erts_activity_t old_activity,
-		 erts_activity_t new_activity,
-		 int locked,
-		 void (*prepare)(void *),
-		 void (*resume)(void *),
-		 void *arg);
-void erts_block_system(Uint32 allowed_activities);
-int erts_emergency_block_system(long timeout, Uint32 allowed_activities);
-void erts_release_system(void);
-void erts_system_block_init(void);
-void erts_set_activity_error(erts_activity_error_t, char *, int);
-#ifdef ERTS_ENABLE_LOCK_CHECK
-void erts_lc_activity_change_begin(void);
-void erts_lc_activity_change_end(void);
-int erts_lc_is_blocking(void);
-#define ERTS_LC_IS_BLOCKING \
-  (erts_smp_pending_system_block() && erts_lc_is_blocking())
-#endif
-#endif
-
-#define erts_smp_activity_begin(NACT, PRP, RSM, ARG)		\
-  erts_smp_set_activity(ERTS_ACTIVITY_UNDEFINED,		\
-			(NACT),					\
-			0,					\
-			(PRP),					\
-			(RSM),					\
-			(ARG),					\
-			__FILE__,				\
-			__LINE__)
-#define erts_smp_activity_change(OACT, NACT, PRP, RSM, ARG)	\
-  erts_smp_set_activity((OACT),					\
-			(NACT),					\
-			0,					\
-			(PRP),					\
-			(RSM),					\
-			(ARG),					\
-			__FILE__,				\
-			__LINE__)
-#define erts_smp_activity_end(OACT, PRP, RSM, ARG)		\
-  erts_smp_set_activity((OACT),					\
-			ERTS_ACTIVITY_UNDEFINED,		\
-			0,					\
-			(PRP),					\
-			(RSM),					\
-			(ARG),					\
-			__FILE__,				\
-			__LINE__)
-
-#define erts_smp_locked_activity_begin(NACT)			\
-  erts_smp_set_activity(ERTS_ACTIVITY_UNDEFINED,		\
-			(NACT),					\
-			1,					\
-			NULL,					\
-			NULL,					\
-			NULL,					\
-			__FILE__,				\
-			__LINE__)
-#define erts_smp_locked_activity_change(OACT, NACT)		\
-  erts_smp_set_activity((OACT),					\
-			(NACT),					\
-			1,					\
-			NULL,					\
-			NULL,					\
-			NULL,					\
-			__FILE__,				\
-			__LINE__)
-#define erts_smp_locked_activity_end(OACT)			\
-  erts_smp_set_activity((OACT),					\
-			ERTS_ACTIVITY_UNDEFINED,		\
-			1,					\
-			NULL,					\
-			NULL,					\
-			NULL,					\
-			__FILE__,				\
-			__LINE__)
-
-
-ERTS_GLB_INLINE int erts_smp_is_system_blocked(erts_activity_t allowed_activities);
-ERTS_GLB_INLINE void erts_smp_block_system(Uint32 allowed_activities);
-ERTS_GLB_INLINE int erts_smp_emergency_block_system(long timeout,
-						    Uint32 allowed_activities);
-ERTS_GLB_INLINE void erts_smp_release_system(void);
-ERTS_GLB_INLINE int erts_smp_pending_system_block(void);
-ERTS_GLB_INLINE void erts_smp_chk_system_block(void (*prepare)(void *),
-					       void (*resume)(void *),
-					       void *arg);
-ERTS_GLB_INLINE void
-erts_smp_set_activity(erts_activity_t old_activity,
-		      erts_activity_t new_activity,
-		      int locked,
-		      void (*prepare)(void *),
-		      void (*resume)(void *),
-		      void *arg,
-		      char *file,
-		      int line);
-
-#if ERTS_GLB_INLINE_INCL_FUNC_DEF
-
-
-ERTS_GLB_INLINE int
-erts_smp_is_system_blocked(erts_activity_t allowed_activities)
-{
-#ifdef ERTS_SMP
-    return erts_is_system_blocked(allowed_activities);
-#else
-    return 1;
-#endif
-}
-
-ERTS_GLB_INLINE void
-erts_smp_block_system(Uint32 allowed_activities)
-{
-#ifdef ERTS_SMP
-    erts_block_system(allowed_activities);
-#endif
-}
-
-ERTS_GLB_INLINE int
-erts_smp_emergency_block_system(long timeout, Uint32 allowed_activities)
-{
-#ifdef ERTS_SMP
-    return erts_emergency_block_system(timeout, allowed_activities);
-#else
-    return 0;
-#endif
-}
-
-ERTS_GLB_INLINE void
-erts_smp_release_system(void)
-{
-#ifdef ERTS_SMP
-    erts_release_system();
-#endif
-}
-
-ERTS_GLB_INLINE int
-erts_smp_pending_system_block(void)
-{
-#ifdef ERTS_SMP
-    return (int) erts_smp_atomic32_read_nob(&erts_system_block_state.do_block);
-#else
-    return 0;
-#endif
-}
-
-
-ERTS_GLB_INLINE void
-erts_smp_chk_system_block(void (*prepare)(void *),
-			  void (*resume)(void *),
-			  void *arg)
-{
-#ifdef ERTS_SMP
-    if (erts_smp_pending_system_block())
-	erts_block_me(prepare, resume, arg);
-#endif
-}
-
-ERTS_GLB_INLINE void
-erts_smp_set_activity(erts_activity_t old_activity,
-		      erts_activity_t new_activity,
-		      int locked,
-		      void (*prepare)(void *),
-		      void (*resume)(void *),
-		      void *arg,
-		      char *file,
-		      int line)
-{
-#ifdef ERTS_SMP
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_activity_change_begin();
-#endif
-    switch (old_activity) {
-    case ERTS_ACTIVITY_UNDEFINED:
-	break;
-    case ERTS_ACTIVITY_WAIT:
-	erts_smp_atomic32_dec_acqb(&erts_system_block_state.in_activity.wait);
-	if (locked) {
-	    /* You are not allowed to leave activity waiting
-	     * without supplying the possibility to block
-	     * unlocked.
-	     */
-	    erts_set_activity_error(ERTS_ACT_ERR_LEAVE_WAIT_UNLOCKED,
-				    file, line);
-	}
-	break;
-    case ERTS_ACTIVITY_GC:
-	erts_smp_atomic32_dec_acqb(&erts_system_block_state.in_activity.gc);
-	break;
-    case ERTS_ACTIVITY_IO:
-	erts_smp_atomic32_dec_acqb(&erts_system_block_state.in_activity.io);
-	break;
-    default:
-	erts_set_activity_error(ERTS_ACT_ERR_LEAVE_UNKNOWN_ACTIVITY,
-				file, line);
-	break;
-    }
-
-    /* We are not allowed to block when going to activity waiting... */
-    if (new_activity != ERTS_ACTIVITY_WAIT && erts_smp_pending_system_block())
-	erts_check_block(old_activity,new_activity,locked,prepare,resume,arg);
-
-    switch (new_activity) {
-    case ERTS_ACTIVITY_UNDEFINED:
-	break;
-    case ERTS_ACTIVITY_WAIT:
-	erts_smp_atomic32_inc_mb(&erts_system_block_state.in_activity.wait);
-	break;
-    case ERTS_ACTIVITY_GC:
-	erts_smp_atomic32_inc_mb(&erts_system_block_state.in_activity.gc);
-	break;
-    case ERTS_ACTIVITY_IO:
-	erts_smp_atomic32_inc_mb(&erts_system_block_state.in_activity.io);
-	break;
-    default:
-	erts_set_activity_error(ERTS_ACT_ERR_ENTER_UNKNOWN_ACTIVITY,
-				file, line);
-	break;
-    }
-
-    switch (new_activity) {
-    case ERTS_ACTIVITY_WAIT:
-    case ERTS_ACTIVITY_GC:
-    case ERTS_ACTIVITY_IO:
-	if (erts_smp_pending_system_block())
-	    erts_note_activity_begin(new_activity);
-	break;
-    default:
-	break;
-    }
-
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_activity_change_end();
-#endif
-
-#endif
-}
-
-#endif /* #if ERTS_GLB_INLINE_INCL_FUNC_DEF */
-
 #if defined(DEBUG) || defined(ERTS_ENABLE_LOCK_CHECK)
 #undef ERTS_REFC_DEBUG
 #define ERTS_REFC_DEBUG
diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index 3fa84bd13c..cc377b543d 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -77,6 +77,7 @@ typedef struct {
 
 #ifdef ERTS_SMP
 
+#if 0 /* Unused */
 static void 
 dispatch_profile_msg_q(profile_sched_msg_q *psmq)
 {
@@ -88,6 +89,7 @@ dispatch_profile_msg_q(profile_sched_msg_q *psmq)
 	profile_scheduler_q(make_small(msg->scheduler_id), msg->state, am_undefined, msg->Ms, msg->s, msg->us);
     }
 }
+#endif
 
 #endif
 
@@ -3338,688 +3340,6 @@ sys_alloc_stat(SysAllocStat *sasp)
 
 }
 
-#ifdef ERTS_SMP
-
-/* Local system block state */
-
-struct {
-    int emergency;
-    long emergency_timeout;
-    erts_smp_cnd_t watchdog_cnd;
-    erts_smp_tid_t watchdog_tid;
-    int threads_to_block;
-    int have_blocker;
-    erts_smp_tid_t blocker_tid;
-    int recursive_block;
-    Uint32 allowed_activities;
-    erts_smp_tsd_key_t blockable_key;
-    erts_smp_mtx_t mtx;
-    erts_smp_cnd_t cnd;
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    int activity_changing;
-    int checking;
-#endif
-} system_block_state;
-
-/* Global system block state */
-erts_system_block_state_t erts_system_block_state;
-
-
-static ERTS_INLINE int
-is_blockable_thread(void)
-{
-    return erts_smp_tsd_get(system_block_state.blockable_key) != NULL;
-}
-
-static ERTS_INLINE int
-is_blocker(void)
-{
-    return (system_block_state.have_blocker
-	    && erts_smp_equal_tids(system_block_state.blocker_tid,
-				   erts_smp_thr_self()));
-}
-
-#ifdef ERTS_ENABLE_LOCK_CHECK
-int
-erts_lc_is_blocking(void)
-{
-    int res;
-    erts_smp_mtx_lock(&system_block_state.mtx);
-    res = erts_smp_pending_system_block() && is_blocker();
-    erts_smp_mtx_unlock(&system_block_state.mtx);
-    return res;
-}
-#endif
-
-static ERTS_INLINE void
-block_me(void (*prepare)(void *),
-	 void (*resume)(void *),
-	 void *arg,
-	 int mtx_locked,
-	 int want_to_block,
-	 int update_act_changing,
-	 profile_sched_msg_q *psmq)
-{
-    if (prepare)
-	(*prepare)(arg);
-
-    /* Locks might be held... */
-
-    if (!mtx_locked)
-	erts_smp_mtx_lock(&system_block_state.mtx);
-
-    if (erts_smp_pending_system_block() && !is_blocker()) {
-	int is_blockable = is_blockable_thread();
-	ASSERT(is_blockable);
-
-	if (is_blockable)
-	    system_block_state.threads_to_block--;
-
-	if (erts_system_profile_flags.scheduler && psmq) {
-	    ErtsSchedulerData *esdp = erts_get_scheduler_data();
-	    if (esdp) {
-	    	profile_sched_msg *msg = NULL;
-	        
-		ASSERT(psmq->n < 2);
-		msg = &((psmq->msg)[psmq->n]);
-		msg->scheduler_id = esdp->no;
-		get_now(&(msg->Ms), &(msg->s), &(msg->us));
-		msg->no_schedulers = 0;
-		msg->state = am_inactive;
-	    	psmq->n++;
-	    }
-	}
-
-#ifdef ERTS_ENABLE_LOCK_CHECK
-	if (update_act_changing)
-	    system_block_state.activity_changing--;
-#endif
-
-	erts_smp_cnd_broadcast(&system_block_state.cnd);
-
-	do {
-	    erts_smp_cnd_wait(&system_block_state.cnd, &system_block_state.mtx);
-	} while (erts_smp_pending_system_block()
-		 && !(want_to_block && !system_block_state.have_blocker));
-
-#ifdef ERTS_ENABLE_LOCK_CHECK
-	if (update_act_changing)
-	    system_block_state.activity_changing++;
-#endif
-	if (erts_system_profile_flags.scheduler && psmq) {
-	    ErtsSchedulerData *esdp = erts_get_scheduler_data();
-	    if (esdp) {
-	    	profile_sched_msg *msg = NULL;
-	        
-		ASSERT(psmq->n < 2);
-		msg = &((psmq->msg)[psmq->n]);
-		msg->scheduler_id = esdp->no;
-		get_now(&(msg->Ms), &(msg->s), &(msg->us));
-		msg->no_schedulers = 0;
-		msg->state = am_active;
-	    	psmq->n++;
-	    }
-	}
-
-	if (is_blockable)
-	    system_block_state.threads_to_block++;
-    }
-
-    if (!mtx_locked)
-	erts_smp_mtx_unlock(&system_block_state.mtx);
-
-    if (resume)
-	(*resume)(arg);
-}
-
-void
-erts_block_me(void (*prepare)(void *),
-	      void (*resume)(void *),
-	      void *arg)
-{
-    profile_sched_msg_q psmq;
-    psmq.n = 0;
-    if (prepare)
-	(*prepare)(arg);
-
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_check_exact(NULL, 0); /* No locks should be locked */
-#endif
-
-    block_me(NULL, NULL, NULL, 0, 0, 0, &psmq);
-
-    if (erts_system_profile_flags.scheduler && psmq.n > 0) 
-    	dispatch_profile_msg_q(&psmq);
-
-    if (resume)
-	(*resume)(arg);
-}
-
-void
-erts_register_blockable_thread(void)
-{
-    profile_sched_msg_q psmq;
-    psmq.n = 0;
-    if (!is_blockable_thread()) {
-	erts_smp_mtx_lock(&system_block_state.mtx);
-	system_block_state.threads_to_block++;
-	erts_smp_tsd_set(system_block_state.blockable_key,
-			 (void *) &erts_system_block_state);
-
-	/* Someone might be waiting for us to block... */
-	if (erts_smp_pending_system_block())
-	    block_me(NULL, NULL, NULL, 1, 0, 0, &psmq);
-	erts_smp_mtx_unlock(&system_block_state.mtx);
-
-	if (erts_system_profile_flags.scheduler && psmq.n > 0)
-	    dispatch_profile_msg_q(&psmq);
-    }
-}
-
-void
-erts_unregister_blockable_thread(void)
-{
-    if (is_blockable_thread()) {
-	erts_smp_mtx_lock(&system_block_state.mtx);
-	system_block_state.threads_to_block--;
-	ASSERT(system_block_state.threads_to_block >= 0);
-	erts_smp_tsd_set(system_block_state.blockable_key, NULL);
-
-	/* Someone might be waiting for us to block... */
-	if (erts_smp_pending_system_block())
-	    erts_smp_cnd_broadcast(&system_block_state.cnd);
-	erts_smp_mtx_unlock(&system_block_state.mtx);
-    }
-}
-
-void
-erts_note_activity_begin(erts_activity_t activity)
-{
-    erts_smp_mtx_lock(&system_block_state.mtx);
-    if (erts_smp_pending_system_block()) {
-	Uint32 broadcast = 0;
-	switch (activity) {
-	case ERTS_ACTIVITY_GC:
-	    broadcast = (system_block_state.allowed_activities
-			 & ERTS_BS_FLG_ALLOW_GC);
-	    break;
-	case ERTS_ACTIVITY_IO:
-	    broadcast = (system_block_state.allowed_activities
-			 & ERTS_BS_FLG_ALLOW_IO);
-	    break;
-	case ERTS_ACTIVITY_WAIT:
-	    broadcast = 1;
-	    break;
-	default:
-	    abort();
-	    break;
-	}
-	if (broadcast)
-	    erts_smp_cnd_broadcast(&system_block_state.cnd);
-    }
-    erts_smp_mtx_unlock(&system_block_state.mtx);
-}
-
-void
-erts_check_block(erts_activity_t old_activity,
-		 erts_activity_t new_activity,
-		 int locked,
-		 void (*prepare)(void *),
-		 void (*resume)(void *),
-		 void *arg)
-{
-    int do_block;
-    profile_sched_msg_q psmq;
-
-    psmq.n = 0;
-    if (!locked && prepare)
-	(*prepare)(arg);
-
-    erts_smp_mtx_lock(&system_block_state.mtx);
-
-    /* First check if it is ok to block... */
-    if (!locked)
-	do_block = 1;
-    else {
-	switch (old_activity) {
-	case ERTS_ACTIVITY_UNDEFINED:
-	    do_block = 0;
-	    break;
-	case ERTS_ACTIVITY_GC:
-	    do_block = (system_block_state.allowed_activities
-			& ERTS_BS_FLG_ALLOW_GC);
-	    break;
-	case ERTS_ACTIVITY_IO:
-	    do_block = (system_block_state.allowed_activities
-			& ERTS_BS_FLG_ALLOW_IO);
-	    break;
-	case ERTS_ACTIVITY_WAIT:
-	    /* You are not allowed to leave activity waiting
-	     * without supplying the possibility to block
-	     * unlocked.
-	     */
-	    erts_set_activity_error(ERTS_ACT_ERR_LEAVE_WAIT_UNLOCKED,
-				    __FILE__, __LINE__);
-	    do_block = 0;
-	    break;
-	default:
-	    erts_set_activity_error(ERTS_ACT_ERR_LEAVE_UNKNOWN_ACTIVITY,
-				    __FILE__, __LINE__);
-	    do_block = 0;
-	    break;
-	}
-    }
-
-    if (do_block) {
-	/* ... then check if it is necessary to block... */
-
-	switch (new_activity) {
-	case ERTS_ACTIVITY_UNDEFINED:
-	    do_block = 1;
-	    break;
-	case ERTS_ACTIVITY_GC:
-	    do_block = !(system_block_state.allowed_activities
-			 & ERTS_BS_FLG_ALLOW_GC);
-	break;
-	case ERTS_ACTIVITY_IO:
-	    do_block = !(system_block_state.allowed_activities
-			 & ERTS_BS_FLG_ALLOW_IO);
-	    break;
-	case ERTS_ACTIVITY_WAIT:
-	    /* No need to block if we are going to wait */
-	    do_block = 0;
-	    break;
-	default:
-	    erts_set_activity_error(ERTS_ACT_ERR_ENTER_UNKNOWN_ACTIVITY,
-				    __FILE__, __LINE__);
-	    break;
-	}
-    }
-
-    if (do_block) {
-
-#ifdef ERTS_ENABLE_LOCK_CHECK
-	if (!locked) {
-	    /* Only system_block_state.mtx should be held */
-	    erts_lc_check_exact(&system_block_state.mtx.lc, 1);
-	}
-#endif
-
-	block_me(NULL, NULL, NULL, 1, 0, 1, &psmq);
-
-    }
-
-    erts_smp_mtx_unlock(&system_block_state.mtx);
-
-    if (erts_system_profile_flags.scheduler && psmq.n > 0) 
-	dispatch_profile_msg_q(&psmq);	
-
-    if (!locked && resume)
-	(*resume)(arg);
-}
-
-
-
-void
-erts_set_activity_error(erts_activity_error_t error, char *file, int line)
-{
-    switch (error) {
-    case ERTS_ACT_ERR_LEAVE_WAIT_UNLOCKED:
-	erl_exit(1, "%s:%d: Fatal error: Leaving activity waiting without "
-		 "supplying the possibility to block unlocked.",
-		 file, line);
-	break;
-    case ERTS_ACT_ERR_LEAVE_UNKNOWN_ACTIVITY:
-	erl_exit(1, "%s:%d: Fatal error: Leaving unknown activity.",
-		 file, line);
-	break;
-    case ERTS_ACT_ERR_ENTER_UNKNOWN_ACTIVITY:
-	erl_exit(1, "%s:%d: Fatal error: Leaving unknown activity.",
-		 file, line);
-	break;
-    default:
-	erl_exit(1, "%s:%d: Internal error in erts_smp_set_activity()",
-		 file, line);
-	break;
-    }
-
-}
-
-
-static ERTS_INLINE erts_aint32_t
-threads_not_under_control(void)
-{
-    erts_aint32_t res = system_block_state.threads_to_block;
-
-    ERTS_THR_MEMORY_BARRIER;
-
-    /* Waiting is always an allowed activity... */
-    res -= erts_smp_atomic32_read_nob(&erts_system_block_state.in_activity.wait);
-
-    if (system_block_state.allowed_activities & ERTS_BS_FLG_ALLOW_GC)
-	res -= erts_smp_atomic32_read_nob(&erts_system_block_state.in_activity.gc);
-
-    if (system_block_state.allowed_activities & ERTS_BS_FLG_ALLOW_IO)
-	res -= erts_smp_atomic32_read_nob(&erts_system_block_state.in_activity.io);
-
-    if (res < 0) {
-	ASSERT(0);
-	return 0;
-    }
-    return res;
-}
-
-/*
- * erts_block_system() blocks all threads registered as blockable.
- * It doesn't return until either all threads have blocked (0 is returned)
- * or it has timed out (ETIMEDOUT) is returned.
- *
- * If allowed activities == 0, blocked threads will release all locks
- * before blocking.
- *
- * If allowed_activities is != 0, erts_block_system() will allow blockable
- * threads to continue executing as long as they are doing an allowed
- * activity. When they are done with the allowed activity they will block,
- * *but* they will block holding locks. Therefore, the thread calling
- * erts_block_system() must *not* try to aquire any locks that might be
- * held by blocked threads holding locks from allowed activities.
- *
- * Currently allowed_activities are:
- *	* ERTS_BS_FLG_ALLOW_GC		Thread continues with garbage
- *					collection and blocks with
- *					main process lock on current
- *					process locked.
- *	* ERTS_BS_FLG_ALLOW_IO		Thread continues with I/O
- */
-
-void
-erts_block_system(Uint32 allowed_activities)
-{
-    int do_block;
-    profile_sched_msg_q psmq;
-    
-    psmq.n = 0;
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_check_exact(NULL, 0); /* No locks should be locked */
-#endif
-
-    erts_smp_mtx_lock(&system_block_state.mtx);
-
-    do_block = erts_smp_pending_system_block();
-    if (do_block
-	&& system_block_state.have_blocker
-	&& erts_smp_equal_tids(system_block_state.blocker_tid,
-			       erts_smp_thr_self())) {
-	ASSERT(system_block_state.recursive_block >= 0);
-	system_block_state.recursive_block++;
-
-	/* You are not allowed to restrict allowed activites
-	   in a recursive block! */
-	ERTS_SMP_LC_ASSERT((system_block_state.allowed_activities
-			    & ~allowed_activities) == 0);
-    }
-    else {
-
-	erts_smp_atomic32_inc_nob(&erts_system_block_state.do_block);
-
-	/* Someone else might be waiting for us to block... */
-	if (do_block) {
-	do_block_me:
-	    block_me(NULL, NULL, NULL, 1, 1, 0, &psmq);
-	}
-
-	ASSERT(!system_block_state.have_blocker);
-	system_block_state.have_blocker = 1;
-	system_block_state.blocker_tid = erts_smp_thr_self();
-	system_block_state.allowed_activities = allowed_activities;
-
-	if (is_blockable_thread())
-	    system_block_state.threads_to_block--;
-
-	while (threads_not_under_control() && !system_block_state.emergency)
-	    erts_smp_cnd_wait(&system_block_state.cnd, &system_block_state.mtx);
-
-	if (system_block_state.emergency) {
-	    system_block_state.have_blocker = 0;
-	    goto do_block_me;
-	}
-    }
-
-    erts_smp_mtx_unlock(&system_block_state.mtx);
-
-    if (erts_system_profile_flags.scheduler && psmq.n > 0 )
-    	dispatch_profile_msg_q(&psmq);
-}
-
-/*
- * erts_emergency_block_system() should only be called when we are
- * about to write a crash dump...
- */
-
-int
-erts_emergency_block_system(long timeout, Uint32 allowed_activities)
-{
-    int res = 0;
-    long another_blocker;
-
-    erts_smp_mtx_lock(&system_block_state.mtx);
-
-    if (system_block_state.emergency) {
-	 /* Argh... */
-	res = EINVAL;
-	goto done;
-    }
-
-    another_blocker = erts_smp_pending_system_block();
-    system_block_state.emergency = 1;
-    erts_smp_atomic32_inc_nob(&erts_system_block_state.do_block);
-
-    if (another_blocker) {
-	if (is_blocker()) {
-	    erts_smp_atomic32_dec_nob(&erts_system_block_state.do_block);
-	    res = 0;
-	    goto done;
-	}
-	/* kick the other blocker */
-	erts_smp_cnd_broadcast(&system_block_state.cnd);
-	while (system_block_state.have_blocker)
-	    erts_smp_cnd_wait(&system_block_state.cnd, &system_block_state.mtx);
-    }
-
-    ASSERT(!system_block_state.have_blocker);
-    system_block_state.have_blocker = 1;
-    system_block_state.blocker_tid = erts_smp_thr_self();
-    system_block_state.allowed_activities = allowed_activities;
-
-    if (is_blockable_thread())
-	system_block_state.threads_to_block--;
-
-    if (timeout < 0) {
-	while (threads_not_under_control())
-	    erts_smp_cnd_wait(&system_block_state.cnd, &system_block_state.mtx);
-    }
-    else {	
-	system_block_state.emergency_timeout = timeout;
-	erts_smp_cnd_signal(&system_block_state.watchdog_cnd);
-
-	while (system_block_state.emergency_timeout >= 0
-	       && threads_not_under_control()) {
-	    erts_smp_cnd_wait(&system_block_state.cnd,
-			      &system_block_state.mtx);
-	}
-    }
- done:
-    erts_smp_mtx_unlock(&system_block_state.mtx);
-    return res;
-}
-
-void
-erts_release_system(void)
-{
-    long do_block;
-    profile_sched_msg_q psmq;
-    
-    psmq.n = 0;
-
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    erts_lc_check_exact(NULL, 0); /* No locks should be locked */
-#endif
-
-    erts_smp_mtx_lock(&system_block_state.mtx);
-    ASSERT(is_blocker());
-
-    ASSERT(system_block_state.recursive_block >= 0);
-
-    if (system_block_state.recursive_block)
-	system_block_state.recursive_block--;
-    else {
-	do_block = erts_smp_atomic32_dec_read_nob(&erts_system_block_state.do_block);
-	system_block_state.have_blocker = 0;
-	if (is_blockable_thread())
-	    system_block_state.threads_to_block++;
-	else
-	    do_block = 0;
-
-	/* Someone else might be waiting for us to block... */
-	if (do_block)
-	    block_me(NULL, NULL, NULL, 1, 0, 0, &psmq);
-	else
-	    erts_smp_cnd_broadcast(&system_block_state.cnd);
-    }
-
-    erts_smp_mtx_unlock(&system_block_state.mtx);
-
-    if (erts_system_profile_flags.scheduler && psmq.n > 0) 
-    	dispatch_profile_msg_q(&psmq);
-}
-
-#ifdef ERTS_ENABLE_LOCK_CHECK
-
-void
-erts_lc_activity_change_begin(void)
-{
-    erts_smp_mtx_lock(&system_block_state.mtx);
-    system_block_state.activity_changing++;
-    erts_smp_mtx_unlock(&system_block_state.mtx);
-}
-
-void
-erts_lc_activity_change_end(void)
-{
-    erts_smp_mtx_lock(&system_block_state.mtx);
-    system_block_state.activity_changing--;
-    if (system_block_state.checking && !system_block_state.activity_changing)
-	erts_smp_cnd_broadcast(&system_block_state.cnd);
-    erts_smp_mtx_unlock(&system_block_state.mtx);
-}
-
-#endif
-
-int
-erts_is_system_blocked(erts_activity_t allowed_activities)
-{
-    int blkd;
-
-    erts_smp_mtx_lock(&system_block_state.mtx);
-    blkd = (erts_smp_pending_system_block()
-	    && system_block_state.have_blocker
-	    && erts_smp_equal_tids(system_block_state.blocker_tid,
-				   erts_smp_thr_self())
-	    && !(system_block_state.allowed_activities & ~allowed_activities));
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    if (blkd) {
-	system_block_state.checking = 1;
-	while (system_block_state.activity_changing)
-	    erts_smp_cnd_wait(&system_block_state.cnd, &system_block_state.mtx);
-	system_block_state.checking = 0;
-	blkd = !threads_not_under_control();
-    }
-#endif
-    erts_smp_mtx_unlock(&system_block_state.mtx);
-    return blkd;
-}
-
-static void *
-emergency_watchdog(void *unused)
-{
-    erts_smp_mtx_lock(&system_block_state.mtx);
-    while (1) {
-	long timeout;
-	while (system_block_state.emergency_timeout < 0)
-	    erts_smp_cnd_wait(&system_block_state.watchdog_cnd, &system_block_state.mtx);
-	timeout = system_block_state.emergency_timeout;
-	erts_smp_mtx_unlock(&system_block_state.mtx);
-
-	if (erts_disable_tolerant_timeofday)
-	    erts_milli_sleep(timeout);
-	else {
-	    SysTimeval to;
-	    erts_get_timeval(&to);
-	    to.tv_sec += timeout / 1000;
-	    to.tv_usec += timeout % 1000;
-
-	    while (1) {
-		SysTimeval curr;
-		erts_milli_sleep(timeout);
-		erts_get_timeval(&curr);
-		if (curr.tv_sec > to.tv_sec
-		    || (curr.tv_sec == to.tv_sec && curr.tv_usec >= to.tv_usec)) {
-		    break;
-		}
-		timeout = (to.tv_sec - curr.tv_sec)*1000;
-		timeout += (to.tv_usec - curr.tv_usec)/1000;
-	    }
-	}
-
-	erts_smp_mtx_lock(&system_block_state.mtx);
-	system_block_state.emergency_timeout = -1;
-	erts_smp_cnd_broadcast(&system_block_state.cnd);
-    }
-    erts_smp_mtx_unlock(&system_block_state.mtx);
-    return NULL;
-}
-
-void
-erts_system_block_init(void)
-{
-    erts_smp_thr_opts_t thr_opts = ERTS_SMP_THR_OPTS_DEFAULT_INITER;
-    /* Local state... */
-    system_block_state.emergency = 0;
-    system_block_state.emergency_timeout = -1;
-    erts_smp_cnd_init(&system_block_state.watchdog_cnd);
-    system_block_state.threads_to_block = 0;
-    system_block_state.have_blocker = 0;
-    /* system_block_state.block_tid */
-    system_block_state.recursive_block = 0;
-    system_block_state.allowed_activities = 0;
-    erts_smp_tsd_key_create(&system_block_state.blockable_key);
-    erts_smp_mtx_init(&system_block_state.mtx, "system_block");
-    erts_smp_cnd_init(&system_block_state.cnd);
-#ifdef ERTS_ENABLE_LOCK_CHECK
-    system_block_state.activity_changing = 0;
-    system_block_state.checking = 0;
-#endif
-
-    thr_opts.suggested_stack_size = 8;
-    erts_smp_thr_create(&system_block_state.watchdog_tid,
-			emergency_watchdog,
-			NULL,
-			&thr_opts);
-
-    /* Global state... */
-
-    erts_smp_atomic32_init_nob(&erts_system_block_state.do_block, 0);
-    erts_smp_atomic32_init_nob(&erts_system_block_state.in_activity.wait, 0);
-    erts_smp_atomic32_init_nob(&erts_system_block_state.in_activity.gc, 0);
-    erts_smp_atomic32_init_nob(&erts_system_block_state.in_activity.io, 0);
-
-    /* Make sure blockable threads unregister when exiting... */
-    erts_smp_install_exit_handler(erts_unregister_blockable_thread);
-}
-
-
-#endif /* #ifdef ERTS_SMP */
-
 char *
 erts_read_env(char *key)
 {