Index: libcfa/src/concurrency/invoke.h
===================================================================
--- libcfa/src/concurrency/invoke.h	(revision 3381ed7a703d0c964d6e94bffab7c58f0cdf0d17)
+++ libcfa/src/concurrency/invoke.h	(revision 50b88854c78d94229d63df8d800995aebc5797b4)
@@ -94,5 +94,4 @@
 	enum coroutine_state { Halted, Start, Primed, Inactive, Active, Rerun, Reschedule };
 	enum __Preemption_Reason { __NO_PREEMPTION, __ALARM_PREEMPTION, __POLL_PREEMPTION };
-	enum __Owner_Reason { __NO_OWNER, __ENTER_FREE, __ENTER_ACCEPT, __ENTER_DTOR_FREE, __ENTER_DTOR_ACCEPT, __ENTER_SIGNAL_BLOCK, __WAITFOR, __LEAVE, __LEAVE_THREAD, __WAIT };
 
 	struct coroutine_desc {
@@ -135,6 +134,4 @@
 		// current owner of the monitor
 		struct thread_desc * owner;
-
-		enum __Owner_Reason owner_reason;
 
 		// queue of threads that are blocked waiting for the monitor
Index: libcfa/src/concurrency/monitor.cfa
===================================================================
--- libcfa/src/concurrency/monitor.cfa	(revision 3381ed7a703d0c964d6e94bffab7c58f0cdf0d17)
+++ libcfa/src/concurrency/monitor.cfa	(revision 50b88854c78d94229d63df8d800995aebc5797b4)
@@ -27,10 +27,10 @@
 //-----------------------------------------------------------------------------
 // Forward declarations
-static inline void set_owner ( monitor_desc * this, thread_desc * owner, enum __Owner_Reason );
-static inline void set_owner ( monitor_desc * storage [], __lock_size_t count, thread_desc * owner, enum __Owner_Reason );
+static inline void set_owner ( monitor_desc * this, thread_desc * owner );
+static inline void set_owner ( monitor_desc * storage [], __lock_size_t count, thread_desc * owner );
 static inline void set_mask  ( monitor_desc * storage [], __lock_size_t count, const __waitfor_mask_t & mask );
 static inline void reset_mask( monitor_desc * this );
 
-static inline thread_desc * next_thread( monitor_desc * this, enum __Owner_Reason );
+static inline thread_desc * next_thread( monitor_desc * this );
 static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & monitors );
 
@@ -94,5 +94,5 @@
 		if( !this->owner ) {
 			// No one has the monitor, just take it
-			set_owner( this, thrd, __ENTER_FREE );
+			set_owner( this, thrd );
 
 			__cfaabi_dbg_print_safe( "Kernel :  mon is free \n" );
@@ -106,5 +106,5 @@
 		else if( is_accepted( this, group) ) {
 			// Some one was waiting for us, enter
-			set_owner( this, thrd, __ENTER_ACCEPT );
+			set_owner( this, thrd );
 
 			// Reset mask
@@ -153,5 +153,5 @@
 
 			// No one has the monitor, just take it
-			set_owner( this, thrd, __ENTER_DTOR_FREE );
+			set_owner( this, thrd );
 
 			verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
@@ -239,5 +239,5 @@
 
 		// Get the next thread, will be null on low contention monitor
-		thread_desc * new_owner = next_thread( this, __LEAVE );
+		thread_desc * new_owner = next_thread( this );
 
 		// Check the new owner is consistent with who we wake-up
@@ -289,5 +289,5 @@
 
 		// Fetch the next thread, can be null
-		thread_desc * new_owner = next_thread( this, __LEAVE_THREAD );
+		thread_desc * new_owner = next_thread( this );
 
 		// Release the monitor lock
@@ -449,5 +449,5 @@
 	// Remove any duplicate threads
 	for( __lock_size_t i = 0; i < count; i++) {
-		thread_desc * new_owner = next_thread( monitors[i], __WAIT );
+		thread_desc * new_owner = next_thread( monitors[i] );
 		insert_unique( threads, thread_count, new_owner );
 	}
@@ -535,5 +535,5 @@
 	thread_desc * signallee = pop_head( this.blocked )->waiting_thread;
 	/* paranoid */ verify( signallee->next == 0p );
-	set_owner( monitors, count, signallee, __ENTER_SIGNAL_BLOCK );
+	set_owner( monitors, count, signallee );
 
 	__cfaabi_dbg_print_buffer_decl( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
@@ -641,5 +641,5 @@
 
 				// Set the owners to be the next thread
-				set_owner( monitors, count, next, __WAITFOR );
+				set_owner( monitors, count, next );
 
 				// unlock all the monitors
@@ -709,10 +709,9 @@
 // Utilities
 
-static inline void set_owner( monitor_desc * this, thread_desc * owner, enum __Owner_Reason reason ) {
+static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
 	/* paranoid */ verify( this->lock.lock );
 
 	//Pass the monitor appropriately
 	this->owner = owner;
-	this->owner_reason = reason;
 
 	//We are passing the monitor to someone else, which means recursion level is not 0
@@ -720,9 +719,8 @@
 }
 
-static inline void set_owner( monitor_desc * monitors [], __lock_size_t count, thread_desc * owner, enum __Owner_Reason reason ) {
+static inline void set_owner( monitor_desc * monitors [], __lock_size_t count, thread_desc * owner ) {
 	/* paranoid */ verify ( monitors[0]->lock.lock );
 	/* paranoid */ verifyf( monitors[0]->owner == kernelTLS.this_thread, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, monitors[0]->owner, monitors[0]->recursion, monitors[0] );
 	monitors[0]->owner        = owner;
-	monitors[0]->owner_reason = reason;
 	monitors[0]->recursion    = 1;
 	for( __lock_size_t i = 1; i < count; i++ ) {
@@ -730,5 +728,4 @@
 		/* paranoid */ verifyf( monitors[i]->owner == kernelTLS.this_thread, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, monitors[i]->owner, monitors[i]->recursion, monitors[i] );
 		monitors[i]->owner        = owner;
-		monitors[i]->owner_reason = reason;
 		monitors[i]->recursion    = 0;
 	}
@@ -747,5 +744,5 @@
 }
 
-static inline thread_desc * next_thread( monitor_desc * this, enum __Owner_Reason reason ) {
+static inline thread_desc * next_thread( monitor_desc * this ) {
 	//Check the signaller stack
 	__cfaabi_dbg_print_safe( "Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
@@ -756,5 +753,5 @@
 		//we need to set the monitor as in use
 		/* paranoid */ verifyf( !this->owner || kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
-		set_owner( this,  urgent->owner->waiting_thread, reason );
+		set_owner( this,  urgent->owner->waiting_thread );
 
 		return check_condition( urgent );
@@ -766,5 +763,5 @@
 	/* paranoid */ verifyf( !this->owner || kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
 	/* paranoid */ verify( !new_owner || new_owner->next == 0p );
-	set_owner( this, new_owner, reason );
+	set_owner( this, new_owner );
 
 	return new_owner;
Index: libcfa/src/concurrency/monitor.hfa
===================================================================
--- libcfa/src/concurrency/monitor.hfa	(revision 3381ed7a703d0c964d6e94bffab7c58f0cdf0d17)
+++ libcfa/src/concurrency/monitor.hfa	(revision 50b88854c78d94229d63df8d800995aebc5797b4)
@@ -32,5 +32,4 @@
 	signal_stack{};
 	owner         = 0p;
-	owner_reason  = __NO_OWNER;
 	recursion     = 0;
 	mask.accepted = 0p;
Index: tests/concurrent/park/force_preempt.cfa
===================================================================
--- tests/concurrent/park/force_preempt.cfa	(revision 3381ed7a703d0c964d6e94bffab7c58f0cdf0d17)
+++ tests/concurrent/park/force_preempt.cfa	(revision 50b88854c78d94229d63df8d800995aebc5797b4)
@@ -21,4 +21,5 @@
 
 void park_loop(Waiter & this, int id, bool force) {
+
 	for(int i = 0; i < 5; i++) {
 		// Unpark this thread, don't force a yield