Index: libcfa/src/concurrency/coroutine.cfa
===================================================================
--- libcfa/src/concurrency/coroutine.cfa	(revision fe610abf35d4cefad3cca4fdc4a9af6b7a838d96)
+++ libcfa/src/concurrency/coroutine.cfa	(revision a182ad5ee947c0c1f30075a88713688a0acd0307)
@@ -85,9 +85,6 @@
 // minimum feasible stack size in bytes
 static const size_t MinStackSize = 1000;
-
-extern "C" {
-	extern size_t __cfa_page_size;				// architecture pagesize HACK, should go in proper runtime singleton
-	extern int __map_prot;
-}
+extern size_t __page_size;				// architecture pagesize HACK, should go in proper runtime singleton
+extern int __map_prot;
 
 void __stack_prepare( __stack_info_t * this, size_t create_size );
@@ -160,22 +157,22 @@
 [void *, size_t] __stack_alloc( size_t storageSize ) {
 	const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
-	assert(__cfa_page_size != 0l);
+	assert(__page_size != 0l);
 	size_t size = libCeiling( storageSize, 16 ) + stack_data_size;
-	size = ceiling(size, __cfa_page_size);
+	size = ceiling(size, __page_size);
 
 	// If we are running debug, we also need to allocate a guardpage to catch stack overflows.
 	void * storage;
 	#if CFA_COROUTINE_USE_MMAP
-		storage = mmap(0p, size + __cfa_page_size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+		storage = mmap(0p, size + __page_size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
 		if(storage == ((void*)-1)) {
 			abort( "coroutine stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) );
 		}
-		if ( mprotect( storage, __cfa_page_size, PROT_NONE ) == -1 ) {
+		if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
 			abort( "coroutine stack creation : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
 		} // if
-		storage = (void *)(((intptr_t)storage) + __cfa_page_size);
+		storage = (void *)(((intptr_t)storage) + __page_size);
 	#else
 		__cfaabi_dbg_debug_do(
-			storage = memalign( __cfa_page_size, size + __cfa_page_size );
+			storage = memalign( __page_size, size + __page_size );
 		);
 		__cfaabi_dbg_no_debug_do(
@@ -184,8 +181,8 @@
 
 		__cfaabi_dbg_debug_do(
-			if ( mprotect( storage, __cfa_page_size, PROT_NONE ) == -1 ) {
+			if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
 				abort( "__stack_alloc : internal error, mprotect failure, error(%d) %s.", (int)errno, strerror( (int)errno ) );
 			}
-			storage = (void *)(((intptr_t)storage) + __cfa_page_size);
+			storage = (void *)(((intptr_t)storage) + __page_size);
 		);
 	#endif
@@ -201,12 +198,12 @@
 	#if CFA_COROUTINE_USE_MMAP
 		size_t size = ((intptr_t)this->storage->base) - ((intptr_t)this->storage->limit) + sizeof(__stack_t);
-		storage = (void *)(((intptr_t)storage) - __cfa_page_size);
-		if(munmap(storage, size + __cfa_page_size) == -1) {
+		storage = (void *)(((intptr_t)storage) - __page_size);
+		if(munmap(storage, size + __page_size) == -1) {
 			abort( "coroutine stack destruction : internal error, munmap failure, error(%d) %s.", errno, strerror( errno ) );
 		}
 	#else
 		__cfaabi_dbg_debug_do(
-			storage = (char*)(storage) - __cfa_page_size;
-			if ( mprotect( storage, __cfa_page_size, __map_prot ) == -1 ) {
+			storage = (char*)(storage) - __page_size;
+			if ( mprotect( storage, __page_size, __map_prot ) == -1 ) {
 				abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
 			}
Index: libcfa/src/concurrency/kernel/startup.cfa
===================================================================
--- libcfa/src/concurrency/kernel/startup.cfa	(revision fe610abf35d4cefad3cca4fdc4a9af6b7a838d96)
+++ libcfa/src/concurrency/kernel/startup.cfa	(revision a182ad5ee947c0c1f30075a88713688a0acd0307)
@@ -122,7 +122,8 @@
 extern "C" {
 	struct { __dllist_t(cluster) list; __spinlock_t lock; } __cfa_dbg_global_clusters;
-	extern size_t __cfa_page_size;
-	extern int __map_prot;
-}
+}
+
+extern size_t __page_size;
+extern int __map_prot;
 
 //-----------------------------------------------------------------------------
@@ -573,4 +574,5 @@
 }
 
+extern size_t __page_size;
 void ^?{}(processor & this) with( this ){
 	/* paranoid */ verify( !__atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) );
@@ -738,17 +740,17 @@
 	void * stack;
 	#if CFA_PROCESSOR_USE_MMAP
-		stacksize = ceiling( stacksize, __cfa_page_size ) + __cfa_page_size;
+		stacksize = ceiling( stacksize, __page_size ) + __page_size;
 		stack = mmap(0p, stacksize, __map_prot, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
 		if(stack == ((void*)-1)) {
 			abort( "pthread stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) );
 		}
-		if ( mprotect( stack, __cfa_page_size, PROT_NONE ) == -1 ) {
+		if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
 			abort( "pthread stack creation : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
 		} // if
 	#else
 		__cfaabi_dbg_debug_do(
-			stack = memalign( __cfa_page_size, stacksize + __cfa_page_size );
+			stack = memalign( __page_size, stacksize + __page_size );
 			// pthread has no mechanism to create the guard page in user supplied stack.
-			if ( mprotect( stack, __cfa_page_size, PROT_NONE ) == -1 ) {
+			if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
 				abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
 			} // if
@@ -777,5 +779,5 @@
 		check( pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
 		assert( stacksize >= PTHREAD_STACK_MIN );
-		stacksize += __cfa_page_size;
+		stacksize += __page_size;
 
 		if(munmap(stack, stacksize) == -1) {
@@ -785,5 +787,5 @@
 		__cfaabi_dbg_debug_do(
 			// pthread has no mechanism to create the guard page in user supplied stack.
-			if ( mprotect( stack, __cfa_page_size, __map_prot ) == -1 ) {
+			if ( mprotect( stack, __page_size, __map_prot ) == -1 ) {
 				abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
 			} // if