Index: src/libcfa/concurrency/kernel
===================================================================
--- src/libcfa/concurrency/kernel	(revision 1f37ed02cc74c64f4e7f522e805e7b6fba4e51ee)
+++ src/libcfa/concurrency/kernel	(revision 094476de228cd8cb7d6a34066aacd6b8adb12617)
@@ -79,9 +79,13 @@
 
 // Processor
+coroutine processorCtx_t {
+	struct processor * proc;
+};
+
 // Wrapper around kernel threads
 struct processor {
 	// Main state
 	// Coroutine ctx who does keeps the state of the processor
-	struct processorCtx_t * runner;
+	struct processorCtx_t runner;
 
 	// Cluster from which to get threads
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision 1f37ed02cc74c64f4e7f522e805e7b6fba4e51ee)
+++ src/libcfa/concurrency/kernel.c	(revision 094476de228cd8cb7d6a34066aacd6b8adb12617)
@@ -124,4 +124,5 @@
 //-----------------------------------------------------------------------------
 // Processor coroutine
+void ?{}(processorCtx_t & this) {}
 
 // Construct the processor context of the main processor
@@ -130,5 +131,4 @@
 	this.__cor.starter = NULL;
 	this.proc = proc;
-	proc->runner = &this;
 }
 
@@ -137,5 +137,4 @@
 	(this.__cor){ info };
 	this.proc = proc;
-	proc->runner = &this;
 }
 
@@ -150,4 +149,5 @@
 	preemption_alarm = NULL;
 	pending_preemption = false;
+	runner.proc = &this;
 
 	start( &this );
@@ -161,6 +161,6 @@
 	pending_preemption = false;
 	kernel_thread = pthread_self();
-
-	this.runner = &runner;
+	runner.proc = &this;
+
 	__cfaabi_dbg_print_safe("Kernel : constructing main processor context %p\n", &runner);
 	runner{ &this };
@@ -196,4 +196,5 @@
 void main(processorCtx_t & runner) {
 	processor * this = runner.proc;
+	verify(this);
 
 	__cfaabi_dbg_print_safe("Kernel : core %p starting\n", this);
@@ -241,5 +242,5 @@
 void runThread(processor * this, thread_desc * dst) {
 	assert(dst->curr_cor);
-	coroutine_desc * proc_cor = get_coroutine(*this->runner);
+	coroutine_desc * proc_cor = get_coroutine(this->runner);
 	coroutine_desc * thrd_cor = dst->curr_cor;
 
@@ -256,5 +257,5 @@
 
 void returnToKernel() {
-	coroutine_desc * proc_cor = get_coroutine(*this_processor->runner);
+	coroutine_desc * proc_cor = get_coroutine(this_processor->runner);
 	coroutine_desc * thrd_cor = this_thread->curr_cor = this_coroutine;
 	ThreadCtxSwitch(thrd_cor, proc_cor);
@@ -317,14 +318,14 @@
 	machine_context_t ctx;
 	info.context = &ctx;
-	processorCtx_t proc_cor_storage = { proc, &info };
-
-	__cfaabi_dbg_print_safe("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
+	(proc->runner){ proc, &info };
+
+	__cfaabi_dbg_print_safe("Coroutine : created stack %p\n", get_coroutine(proc->runner)->stack.base);
 
 	//Set global state
-	this_coroutine = &proc->runner->__cor;
+	this_coroutine = get_coroutine(proc->runner);
 	this_thread = NULL;
 
 	//We now have a proper context from which to schedule threads
-	__cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx);
+	__cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, &proc->runner, &ctx);
 
 	// SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't
@@ -332,10 +333,10 @@
 	// back to here. Instead directly call the main since we already are on the
 	// appropriate stack.
-	proc_cor_storage.__cor.state = Active;
-	main( proc_cor_storage );
-	proc_cor_storage.__cor.state = Halted;
+	get_coroutine(proc->runner)->state = Active;
+	main( proc->runner );
+	get_coroutine(proc->runner)->state = Halted;
 
 	// Main routine of the core returned, the core is now fully terminated
-	__cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, proc->runner);
+	__cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, &proc->runner);
 
 	return NULL;
@@ -352,10 +353,10 @@
 void kernel_first_resume(processor * this) {
 	coroutine_desc * src = this_coroutine;
-	coroutine_desc * dst = get_coroutine(*this->runner);
+	coroutine_desc * dst = get_coroutine(this->runner);
 
 	verify( !preemption_state.enabled );
 
 	create_stack(&dst->stack, dst->stack.size);
-	CtxStart(this->runner, CtxInvokeCoroutine);
+	CtxStart(&this->runner, CtxInvokeCoroutine);
 
 	verify( !preemption_state.enabled );
@@ -411,12 +412,4 @@
 	verify( !preemption_state.enabled );
 	lock( ready_queue_lock __cfaabi_dbg_ctx2 );
-	//TEMP hack to find a bug
-	if(this_processor != mainProcessor) {
-		if(ready_queue.head == mainThread) {
-			unlock( ready_queue_lock );
-			return NULL;
-		}
-	}
-
 	thread_desc * head = pop_head( ready_queue );
 	unlock( ready_queue_lock );
@@ -584,5 +577,5 @@
 	// Destroy the main processor and its context in reverse order of construction
 	// These were manually constructed so we need manually destroy them
-	^(*mainProcessor->runner){};
+	^(mainProcessor->runner){};
 	^(mainProcessor){};
 
Index: src/libcfa/concurrency/kernel_private.h
===================================================================
--- src/libcfa/concurrency/kernel_private.h	(revision 1f37ed02cc74c64f4e7f522e805e7b6fba4e51ee)
+++ src/libcfa/concurrency/kernel_private.h	(revision 094476de228cd8cb7d6a34066aacd6b8adb12617)
@@ -52,8 +52,4 @@
 //-----------------------------------------------------------------------------
 // Processor
-coroutine processorCtx_t {
-	processor * proc;
-};
-
 void main(processorCtx_t *);
 void start(processor * this);