Index: src/libcfa/concurrency/coroutine.c
===================================================================
--- src/libcfa/concurrency/coroutine.c	(revision 5fec3f6589753dd1111fa51da42185c12bd181c3)
+++ src/libcfa/concurrency/coroutine.c	(revision afd550c52f430d2e5d349e8b8fac16a377f429da)
@@ -85,5 +85,5 @@
 void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
       // Safety note : This could cause some false positives due to preemption
-      verify( TL_GET( preemption_state ).enabled || TL_GET( this_processor )->do_terminate );
+      verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate );
       disable_interrupts();
 
@@ -104,5 +104,5 @@
       enable_interrupts( __cfaabi_dbg_ctx );
       // Safety note : This could cause some false positives due to preemption
-      verify( TL_GET( preemption_state ).enabled || TL_GET( this_processor )->do_terminate );
+      verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate );
 } //ctxSwitchDirect
 
Index: src/libcfa/concurrency/invoke.c
===================================================================
--- src/libcfa/concurrency/invoke.c	(revision 5fec3f6589753dd1111fa51da42185c12bd181c3)
+++ src/libcfa/concurrency/invoke.c	(revision afd550c52f430d2e5d349e8b8fac16a377f429da)
@@ -69,4 +69,5 @@
 	// Fetch the thread handle from the user defined thread structure
 	struct thread_desc* thrd = get_thread( this );
+	thrd->self_cor.last = NULL;
 
 	// Officially start the thread by enabling preemption
Index: src/libcfa/concurrency/invoke.h
===================================================================
--- src/libcfa/concurrency/invoke.h	(revision 5fec3f6589753dd1111fa51da42185c12bd181c3)
+++ src/libcfa/concurrency/invoke.h	(revision afd550c52f430d2e5d349e8b8fac16a377f429da)
@@ -49,5 +49,5 @@
 	static inline struct coroutine_desc * volatile active_coroutine() { return TL_GET( this_coroutine ); }
 	static inline struct thread_desc    * volatile active_thread   () { return TL_GET( this_thread    ); }
-	// static inline struct processor      * volatile active_processor() { return TL_GET( this_processor ); } // UNSAFE
+	static inline struct processor      * volatile active_processor() { return TL_GET( this_processor ); } // UNSAFE
 	#endif
 
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision 5fec3f6589753dd1111fa51da42185c12bd181c3)
+++ src/libcfa/concurrency/kernel.c	(revision afd550c52f430d2e5d349e8b8fac16a377f429da)
@@ -422,7 +422,7 @@
 	}
 
-	verify( ! preemption_state.enabled );
+	verify( ! kernelTLS.preemption_state.enabled );
 	returnToKernel();
-	verify( ! preemption_state.enabled );
+	verify( ! kernelTLS.preemption_state.enabled );
 
 	enable_interrupts( __cfaabi_dbg_ctx );
@@ -578,5 +578,5 @@
 	verify( ! kernelTLS.preemption_state.enabled );
 	enable_interrupts( __cfaabi_dbg_ctx );
-	verify( TL_GET( preemption_state ).enabled );
+	verify( TL_GET( preemption_state.enabled ) );
 }
 
@@ -584,5 +584,5 @@
 	__cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
 
-	verify( TL_GET( preemption_state ).enabled );
+	verify( TL_GET( preemption_state.enabled ) );
 	disable_interrupts();
 	verify( ! kernelTLS.preemption_state.enabled );
@@ -642,5 +642,5 @@
 static bool kernel_abort_called = false;
 
-void * kernel_abort    (void) __attribute__ ((__nothrow__)) {
+void * kernel_abort(void) __attribute__ ((__nothrow__)) {
 	// abort cannot be recursively entered by the same or different processors because all signal handlers return when
 	// the globalAbort flag is true.
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision 5fec3f6589753dd1111fa51da42185c12bd181c3)
+++ src/libcfa/concurrency/monitor.c	(revision afd550c52f430d2e5d349e8b8fac16a377f429da)
@@ -480,5 +480,5 @@
 
 	// Create the node specific to this wait operation
-	wait_ctx_primed( TL_GET( this_thread ), 0 )
+	wait_ctx_primed( kernelTLS.this_thread, 0 )
 
 	//save contexts
Index: src/libcfa/concurrency/preemption.c
===================================================================
--- src/libcfa/concurrency/preemption.c	(revision 5fec3f6589753dd1111fa51da42185c12bd181c3)
+++ src/libcfa/concurrency/preemption.c	(revision afd550c52f430d2e5d349e8b8fac16a377f429da)
@@ -149,5 +149,5 @@
 	// Disable interrupts by incrementing the counter
 	void disable_interrupts() {
-		with( TL_GET( preemption_state ) ) {
+		with( kernelTLS.preemption_state ) {
 			enabled = false;
 			__attribute__((unused)) unsigned short new_val = disable_count + 1;
@@ -160,8 +160,8 @@
 	// If counter reaches 0, execute any pending CtxSwitch
 	void enable_interrupts( __cfaabi_dbg_ctx_param ) {
-		processor   * proc = TL_GET( this_processor ); // Cache the processor now since interrupts can start happening after the atomic add
-		thread_desc * thrd = TL_GET( this_thread );	  // Cache the thread now since interrupts can start happening after the atomic add
-
-		with( TL_GET( preemption_state ) ){
+		processor   * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic add
+		thread_desc * thrd = kernelTLS.this_thread;	  // Cache the thread now since interrupts can start happening after the atomic add
+
+		with( kernelTLS.preemption_state ){
 			unsigned short prev = disable_count;
 			disable_count -= 1;
@@ -185,9 +185,9 @@
 	// Don't execute any pending CtxSwitch even if counter reaches 0
 	void enable_interrupts_noPoll() {
-		unsigned short prev = TL_GET( preemption_state ).disable_count;
-		TL_GET( preemption_state ).disable_count -= 1;
+		unsigned short prev = kernelTLS.preemption_state.disable_count;
+		kernelTLS.preemption_state.disable_count -= 1;
 		verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
 		if( prev == 1 ) {
-			TL_GET( preemption_state ).enabled = true;
+			kernelTLS.preemption_state.enabled = true;
 		}
 	}
Index: src/libcfa/concurrency/thread.c
===================================================================
--- src/libcfa/concurrency/thread.c	(revision 5fec3f6589753dd1111fa51da42185c12bd181c3)
+++ src/libcfa/concurrency/thread.c	(revision afd550c52f430d2e5d349e8b8fac16a377f429da)
@@ -100,8 +100,8 @@
 void yield( void ) {
 	// Safety note : This could cause some false positives due to preemption
-      verify( TL_GET( preemption_state ).enabled );
+      verify( TL_GET( preemption_state.enabled ) );
 	BlockInternal( TL_GET( this_thread ) );
 	// Safety note : This could cause some false positives due to preemption
-      verify( TL_GET( preemption_state ).enabled );
+      verify( TL_GET( preemption_state.enabled ) );
 }