Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision b1672e1c5cb9c30308d9fa20216c709b6ac5be58)
+++ src/libcfa/concurrency/kernel.c	(revision bd21af5451f36317f686c0d5d45b5c6efbec760c)
@@ -37,6 +37,6 @@
 
 //Start and stop routine for the kernel, declared first to make sure they run first
-void kernel_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
-void kernel_shutdown(void) __attribute__(( destructor ( STARTUP_PRIORITY_KERNEL ) ));
+static void kernel_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
+static void kernel_shutdown(void) __attribute__(( destructor ( STARTUP_PRIORITY_KERNEL ) ));
 
 //-----------------------------------------------------------------------------
@@ -133,9 +133,10 @@
 
 // Construct the processor context of non-main processors
-void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info) {
+static void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info) {
 	(this.__cor){ info };
 	this.proc = proc;
 }
 
+static void start(processor * this);
 void ?{}(processor & this, const char * name, cluster & cltr) with( this ) {
 	this.name = name;
@@ -186,4 +187,8 @@
 // Kernel Scheduling logic
 //=============================================================================================
+static void runThread(processor * this, thread_desc * dst);
+static void finishRunning(processor * this);
+static void halt(processor * this);
+
 //Main of the processor contexts
 void main(processorCtx_t & runner) {
@@ -239,5 +244,5 @@
 // runThread runs a thread by context switching
 // from the processor coroutine to the target thread
-void runThread(processor * this, thread_desc * dst) {
+static void runThread(processor * this, thread_desc * dst) {
 	assert(dst->curr_cor);
 	coroutine_desc * proc_cor = get_coroutine(this->runner);
@@ -256,5 +261,5 @@
 
 // KERNEL_ONLY
-void returnToKernel() {
+static void returnToKernel() {
 	coroutine_desc * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
 	coroutine_desc * thrd_cor = kernelTLS.this_thread->curr_cor = kernelTLS.this_coroutine;
@@ -265,5 +270,5 @@
 // Once a thread has finished running, some of
 // its final actions must be executed from the kernel
-void finishRunning(processor * this) with( this->finish ) {
+static void finishRunning(processor * this) with( this->finish ) {
 	verify( ! kernelTLS.preemption_state.enabled );
 	choose( action_code ) {
@@ -299,5 +304,5 @@
 // This is the entry point for processors (kernel threads)
 // It effectively constructs a coroutine by stealing the pthread stack
-void * CtxInvokeProcessor(void * arg) {
+static void * CtxInvokeProcessor(void * arg) {
 	processor * proc = (processor *) arg;
 	kernelTLS.this_processor = proc;
@@ -336,5 +341,5 @@
 }
 
-void start(processor * this) {
+static void start(processor * this) {
 	__cfaabi_dbg_print_safe("Kernel : Starting core %p\n", this);
 
@@ -542,5 +547,5 @@
 //-----------------------------------------------------------------------------
 // Kernel boot procedures
-void kernel_startup(void) {
+static void kernel_startup(void) {
 	verify( ! kernelTLS.preemption_state.enabled );
 	__cfaabi_dbg_print_safe("Kernel : Starting\n");
@@ -618,5 +623,5 @@
 }
 
-void kernel_shutdown(void) {
+static void kernel_shutdown(void) {
 	__cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
 
@@ -655,6 +660,5 @@
 // Kernel Quiescing
 //=============================================================================================
-
-void halt(processor * this) with( *this ) {
+static void halt(processor * this) with( *this ) {
 	// verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
 
@@ -683,6 +687,4 @@
 // Unexpected Terminating logic
 //=============================================================================================
-
-
 static __spinlock_t kernel_abort_lock;
 static bool kernel_abort_called = false;
Index: src/libcfa/concurrency/kernel_private.h
===================================================================
--- src/libcfa/concurrency/kernel_private.h	(revision b1672e1c5cb9c30308d9fa20216c709b6ac5be58)
+++ src/libcfa/concurrency/kernel_private.h	(revision bd21af5451f36317f686c0d5d45b5c6efbec760c)
@@ -54,8 +54,4 @@
 // Processor
 void main(processorCtx_t *);
-void start(processor * this);
-void runThread(processor * this, thread_desc * dst);
-void finishRunning(processor * this);
-void halt(processor * this);
 
 static inline void wake_fast(processor * this) {
Index: src/libcfa/concurrency/preemption.c
===================================================================
--- src/libcfa/concurrency/preemption.c	(revision b1672e1c5cb9c30308d9fa20216c709b6ac5be58)
+++ src/libcfa/concurrency/preemption.c	(revision bd21af5451f36317f686c0d5d45b5c6efbec760c)
@@ -39,12 +39,12 @@
 
 // FwdDeclarations : Signal handlers
-void sigHandler_ctxSwitch( __CFA_SIGPARMS__ );
-void sigHandler_segv     ( __CFA_SIGPARMS__ );
-void sigHandler_ill      ( __CFA_SIGPARMS__ );
-void sigHandler_fpe      ( __CFA_SIGPARMS__ );
-void sigHandler_abort    ( __CFA_SIGPARMS__ );
+static void sigHandler_ctxSwitch( __CFA_SIGPARMS__ );
+static void sigHandler_segv     ( __CFA_SIGPARMS__ );
+static void sigHandler_ill      ( __CFA_SIGPARMS__ );
+static void sigHandler_fpe      ( __CFA_SIGPARMS__ );
+static void sigHandler_abort    ( __CFA_SIGPARMS__ );
 
 // FwdDeclarations : alarm thread main
-void * alarm_loop( __attribute__((unused)) void * args );
+static void * alarm_loop( __attribute__((unused)) void * args );
 
 // Machine specific register name
@@ -63,5 +63,5 @@
 static pthread_t alarm_thread;                        // pthread handle to alarm thread
 
-void ?{}(event_kernel_t & this) with( this ) {
+static void ?{}(event_kernel_t & this) with( this ) {
 	alarms{};
 	lock{};
@@ -85,5 +85,5 @@
 
 // Tick one frame of the Discrete Event Simulation for alarms
-void tick_preemption() {
+static void tick_preemption() {
 	alarm_node_t * node = NULL;                     // Used in the while loop but cannot be declared in the while condition
 	alarm_list_t * alarms = &event_kernel->alarms;  // Local copy for ease of reading
@@ -350,5 +350,5 @@
 // Context switch signal handler
 // Receives SIGUSR1 signal and causes the current thread to yield
-void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) {
+static void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) {
 	__cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.CFA_REG_IP); )
 
@@ -393,5 +393,5 @@
 // Main of the alarm thread
 // Waits on SIGALRM and send SIGUSR1 to whom ever needs it
-void * alarm_loop( __attribute__((unused)) void * args ) {
+static void * alarm_loop( __attribute__((unused)) void * args ) {
 	// Block sigalrms to control when they arrive
 	sigset_t mask;
Index: src/libcfa/concurrency/preemption.h
===================================================================
--- src/libcfa/concurrency/preemption.h	(revision b1672e1c5cb9c30308d9fa20216c709b6ac5be58)
+++ src/libcfa/concurrency/preemption.h	(revision bd21af5451f36317f686c0d5d45b5c6efbec760c)
@@ -22,5 +22,4 @@
 void kernel_stop_preemption();
 void update_preemption( processor * this, Duration duration );
-void tick_preemption();
 
 struct preemption_scope {