Index: libcfa/src/concurrency/alarm.cfa
===================================================================
--- libcfa/src/concurrency/alarm.cfa	(revision c6c7e6cd5d9e1471e24ed99b383e023f0fc0bf04)
+++ libcfa/src/concurrency/alarm.cfa	(revision a3821fa7cd1cd775ef0f5213a7acc97154de0d95)
@@ -116,5 +116,5 @@
 	unlock( event_kernel->lock );
 	this->set = true;
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 }
 
@@ -127,5 +127,5 @@
 	}
 	unlock( event_kernel->lock );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 	this->set = false;
 }
Index: libcfa/src/concurrency/clib/cfathread.cfa
===================================================================
--- libcfa/src/concurrency/clib/cfathread.cfa	(revision c6c7e6cd5d9e1471e24ed99b383e023f0fc0bf04)
+++ libcfa/src/concurrency/clib/cfathread.cfa	(revision a3821fa7cd1cd775ef0f5213a7acc97154de0d95)
@@ -117,5 +117,5 @@
 
 	this_thrd->state = Ready;
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 }
 
Index: libcfa/src/concurrency/invoke.c
===================================================================
--- libcfa/src/concurrency/invoke.c	(revision c6c7e6cd5d9e1471e24ed99b383e023f0fc0bf04)
+++ libcfa/src/concurrency/invoke.c	(revision a3821fa7cd1cd775ef0f5213a7acc97154de0d95)
@@ -34,5 +34,5 @@
 
 extern void disable_interrupts() OPTIONAL_THREAD;
-extern void enable_interrupts( __cfaabi_dbg_ctx_param );
+extern void enable_interrupts( _Bool poll );
 
 void __cfactx_invoke_coroutine(
@@ -82,5 +82,5 @@
 ) {
 	// Officially start the thread by enabling preemption
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts( true );
 
 	// Call the main of the thread
Index: libcfa/src/concurrency/io.cfa
===================================================================
--- libcfa/src/concurrency/io.cfa	(revision c6c7e6cd5d9e1471e24ed99b383e023f0fc0bf04)
+++ libcfa/src/concurrency/io.cfa	(revision a3821fa7cd1cd775ef0f5213a7acc97154de0d95)
@@ -244,5 +244,5 @@
 			// Allocation was successful
 			__STATS__( true, io.alloc.fast += 1; )
-			enable_interrupts( __cfaabi_dbg_ctx );
+			enable_interrupts();
 
 			__cfadbg_print_safe(io, "Kernel I/O : fast allocation successful from ring %d\n", ctx->fd);
@@ -256,5 +256,5 @@
 		// Fast path failed, fallback on arbitration
 		__STATS__( true, io.alloc.slow += 1; )
-		enable_interrupts( __cfaabi_dbg_ctx );
+		enable_interrupts();
 
 		$io_arbiter * ioarb = proc->cltr->io.arbiter;
@@ -314,5 +314,5 @@
 			// Mark the instance as no longer in-use, re-enable interrupts and return
 			__STATS__( true, io.submit.fast += 1; )
-			enable_interrupts( __cfaabi_dbg_ctx );
+			enable_interrupts();
 
 			__cfadbg_print_safe(io, "Kernel I/O : submitted on fast path\n");
@@ -322,5 +322,5 @@
 		// Fast path failed, fallback on arbitration
 		__STATS__( true, io.submit.slow += 1; )
-		enable_interrupts( __cfaabi_dbg_ctx );
+		enable_interrupts();
 
 		__cfadbg_print_safe(io, "Kernel I/O : falling back on arbiter for submission\n");
Index: libcfa/src/concurrency/kernel.cfa
===================================================================
--- libcfa/src/concurrency/kernel.cfa	(revision c6c7e6cd5d9e1471e24ed99b383e023f0fc0bf04)
+++ libcfa/src/concurrency/kernel.cfa	(revision a3821fa7cd1cd775ef0f5213a7acc97154de0d95)
@@ -126,4 +126,16 @@
 extern void __disable_interrupts_hard();
 extern void __enable_interrupts_hard();
+
+static inline void __disable_interrupts_checked() {
+	/* paranoid */ verify( __preemption_enabled() );
+	disable_interrupts();
+	/* paranoid */ verify( ! __preemption_enabled() );
+}
+
+static inline void __enable_interrupts_checked( bool poll = true ) {
+	/* paranoid */ verify( ! __preemption_enabled() );
+	enable_interrupts( poll );
+	/* paranoid */ verify( __preemption_enabled() );
+}
 
 //=============================================================================================
@@ -517,30 +529,16 @@
 
 	if(__must_unpark(thrd)) {
-		/* paranoid */ verify( publicTLS_get(this_proc_id) );
 		disable_interrupts();
-
-		/* paranoid */ verify( ! __preemption_enabled() );
-
-		// Wake lost the race,
-		__schedule_thread( thrd );
-
-		/* paranoid */ verify( ! __preemption_enabled() );
-
-		enable_interrupts_noPoll();
-		/* paranoid */ verify( publicTLS_get(this_proc_id) );
+			// Wake lost the race,
+			__schedule_thread( thrd );
+		enable_interrupts(false);
 	}
 }
 
 void park( void ) {
-	/* paranoid */ verify( __preemption_enabled() );
-	disable_interrupts();
-	/* paranoid */ verify( ! __preemption_enabled() );
-	/* paranoid */ verify( kernelTLS().this_thread->preempted == __NO_PREEMPTION );
-
-	returnToKernel();
-
-	/* paranoid */ verify( ! __preemption_enabled() );
-	enable_interrupts( __cfaabi_dbg_ctx );
-	/* paranoid */ verify( __preemption_enabled() );
+	__disable_interrupts_checked();
+		/* paranoid */ verify( kernelTLS().this_thread->preempted == __NO_PREEMPTION );
+		returnToKernel();
+	__enable_interrupts_checked();
 
 }
@@ -582,26 +580,19 @@
 // KERNEL ONLY
 bool force_yield( __Preemption_Reason reason ) {
-	/* paranoid */ verify( __preemption_enabled() );
-	disable_interrupts();
-	/* paranoid */ verify( ! __preemption_enabled() );
-
-	$thread * thrd = kernelTLS().this_thread;
-	/* paranoid */ verify(thrd->state == Active);
-
-	// SKULLDUGGERY: It is possible that we are preempting this thread just before
-	// it was going to park itself. If that is the case and it is already using the
-	// intrusive fields then we can't use them to preempt the thread
-	// If that is the case, abandon the preemption.
-	bool preempted = false;
-	if(thrd->link.next == 0p) {
-		preempted = true;
-		thrd->preempted = reason;
-		returnToKernel();
-	}
-
-	/* paranoid */ verify( ! __preemption_enabled() );
-	enable_interrupts_noPoll();
-	/* paranoid */ verify( __preemption_enabled() );
-
+	__disable_interrupts_checked();
+		$thread * thrd = kernelTLS().this_thread;
+		/* paranoid */ verify(thrd->state == Active);
+
+		// SKULLDUGGERY: It is possible that we are preempting this thread just before
+		// it was going to park itself. If that is the case and it is already using the
+		// intrusive fields then we can't use them to preempt the thread
+		// If that is the case, abandon the preemption.
+		bool preempted = false;
+		if(thrd->link.next == 0p) {
+			preempted = true;
+			thrd->preempted = reason;
+			returnToKernel();
+		}
+	__enable_interrupts_checked( false );
 	return preempted;
 }
@@ -648,10 +639,10 @@
 	__cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this);
 
-	disable_interrupts();
+	__disable_interrupts_checked();
 		/* paranoid */ verify( ! __preemption_enabled() );
 		eventfd_t val;
 		val = 1;
 		eventfd_write( this->idle, val );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	__enable_interrupts_checked();
 }
 
Index: libcfa/src/concurrency/kernel/fwd.hfa
===================================================================
--- libcfa/src/concurrency/kernel/fwd.hfa	(revision c6c7e6cd5d9e1471e24ed99b383e023f0fc0bf04)
+++ libcfa/src/concurrency/kernel/fwd.hfa	(revision a3821fa7cd1cd775ef0f5213a7acc97154de0d95)
@@ -108,6 +108,5 @@
 
 	extern void disable_interrupts();
-	extern void enable_interrupts_noPoll();
-	extern void enable_interrupts( __cfaabi_dbg_ctx_param );
+	extern void enable_interrupts( bool poll = false );
 
 	extern "Cforall" {
@@ -403,5 +402,5 @@
 					__VA_ARGS__ \
 				} \
-				if( !(in_kernel) ) enable_interrupts( __cfaabi_dbg_ctx ); \
+				if( !(in_kernel) ) enable_interrupts(); \
 			}
 		#else
Index: libcfa/src/concurrency/kernel/startup.cfa
===================================================================
--- libcfa/src/concurrency/kernel/startup.cfa	(revision c6c7e6cd5d9e1471e24ed99b383e023f0fc0bf04)
+++ libcfa/src/concurrency/kernel/startup.cfa	(revision a3821fa7cd1cd775ef0f5213a7acc97154de0d95)
@@ -238,5 +238,5 @@
 
 	/* paranoid */ verify( ! __preemption_enabled() );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 	/* paranoid */ verify( __preemption_enabled() );
 
@@ -530,5 +530,5 @@
 	disable_interrupts();
 		init( this, name, _cltr, initT );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 
 	__cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this);
@@ -557,5 +557,5 @@
 	disable_interrupts();
 		deinit( this );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 }
 
@@ -595,5 +595,5 @@
 	// Unlock the RWlock
 	ready_mutate_unlock( last_size );
-	enable_interrupts_noPoll(); // Don't poll, could be in main cluster
+	enable_interrupts( false ); // Don't poll, could be in main cluster
 }
 
@@ -610,5 +610,5 @@
 	// Unlock the RWlock
 	ready_mutate_unlock( last_size );
-	enable_interrupts_noPoll(); // Don't poll, could be in main cluster
+	enable_interrupts( false ); // Don't poll, could be in main cluster
 
 	#if !defined(__CFA_NO_STATISTICS__)
Index: libcfa/src/concurrency/kernel_private.hfa
===================================================================
--- libcfa/src/concurrency/kernel_private.hfa	(revision c6c7e6cd5d9e1471e24ed99b383e023f0fc0bf04)
+++ libcfa/src/concurrency/kernel_private.hfa	(revision a3821fa7cd1cd775ef0f5213a7acc97154de0d95)
@@ -29,6 +29,5 @@
 extern "C" {
 	void disable_interrupts() OPTIONAL_THREAD;
-	void enable_interrupts_noPoll();
-	void enable_interrupts( __cfaabi_dbg_ctx_param );
+	void enable_interrupts( bool poll = true );
 }
 
Index: libcfa/src/concurrency/preemption.cfa
===================================================================
--- libcfa/src/concurrency/preemption.cfa	(revision c6c7e6cd5d9e1471e24ed99b383e023f0fc0bf04)
+++ libcfa/src/concurrency/preemption.cfa	(revision a3821fa7cd1cd775ef0f5213a7acc97154de0d95)
@@ -315,8 +315,8 @@
 	// Enable interrupts by decrementing the counter
 	// If counter reaches 0, execute any pending __cfactx_switch
-	void enable_interrupts( __cfaabi_dbg_ctx_param ) {
+	void enable_interrupts( bool poll ) {
 		// Cache the processor now since interrupts can start happening after the atomic store
 		processor   * proc = __cfaabi_tls.this_processor;
-		/* paranoid */ verify( proc );
+		/* paranoid */ verify( !poll || proc );
 
 		with( __cfaabi_tls.preemption_state ){
@@ -340,33 +340,9 @@
 				// Signal the compiler that a fence is needed but only for signal handlers
 				__atomic_signal_fence(__ATOMIC_RELEASE);
-				if( proc->pending_preemption ) {
+				if( poll && proc->pending_preemption ) {
 					proc->pending_preemption = false;
 					force_yield( __POLL_PREEMPTION );
 				}
 			}
-		}
-
-		// For debugging purposes : keep track of the last person to enable the interrupts
-		__cfaabi_dbg_debug_do( proc->last_enable = caller; )
-	}
-
-	// Disable interrupts by incrementint the counter
-	// Don't execute any pending __cfactx_switch even if counter reaches 0
-	void enable_interrupts_noPoll() {
-		unsigned short prev = __cfaabi_tls.preemption_state.disable_count;
-		__cfaabi_tls.preemption_state.disable_count -= 1;
-		// If this triggers someone is enabled already enabled interrupts
-		/* paranoid */ verifyf( prev != 0u, "Incremented from %u\n", prev );
-		if( prev == 1 ) {
-			#if GCC_VERSION > 50000
-				static_assert(__atomic_always_lock_free(sizeof(__cfaabi_tls.preemption_state.enabled), &__cfaabi_tls.preemption_state.enabled), "Must be lock-free");
-			#endif
-			// Set enabled flag to true
-			// should be atomic to avoid preemption in the middle of the operation.
-			// use memory order RELAXED since there is no inter-thread on this variable requirements
-			__atomic_store_n(&__cfaabi_tls.preemption_state.enabled, true, __ATOMIC_RELAXED);
-
-			// Signal the compiler that a fence is needed but only for signal handlers
-			__atomic_signal_fence(__ATOMIC_RELEASE);
 		}
 	}
Index: libcfa/src/concurrency/thread.cfa
===================================================================
--- libcfa/src/concurrency/thread.cfa	(revision c6c7e6cd5d9e1471e24ed99b383e023f0fc0bf04)
+++ libcfa/src/concurrency/thread.cfa	(revision a3821fa7cd1cd775ef0f5213a7acc97154de0d95)
@@ -135,5 +135,5 @@
 
 	__schedule_thread( this_thrd );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 }
 
@@ -168,5 +168,5 @@
 	disable_interrupts();
 	uint64_t ret = __tls_rand();
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 	return ret;
 }