Index: libcfa/src/bits/defs.hfa
===================================================================
--- libcfa/src/bits/defs.hfa	(revision 20be7824be588cb516b811f2b84e12e776350a51)
+++ libcfa/src/bits/defs.hfa	(revision 428adbc385306e56a64258b0aab447c8dc5e0b6c)
@@ -21,5 +21,5 @@
 #include <stdint.h>
 #include <assert.h>
-
+#include <signal.h>
 
 #define likely(x)   __builtin_expect(!!(x), 1)
@@ -53,6 +53,6 @@
 	int real_pthread_attr_setstack( pthread_attr_t *attr, void *stackaddr, size_t stacksize );
 	int real_pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize );
-	//int real_pthread_sigqueue(pthread_t _thread, int sig, const union sigval value);
-	//int real_pthread_sigmask( int /* how */, const sigset_t * /* set */, sigset_t * /* oset */ );
+	int real_pthread_sigqueue(pthread_t _thread, int sig, const union sigval value);
+	int real_pthread_sigmask( int how, const sigset_t *set, sigset_t *oset);
 }
 #endif
Index: libcfa/src/concurrency/io.cfa
===================================================================
--- libcfa/src/concurrency/io.cfa	(revision 20be7824be588cb516b811f2b84e12e776350a51)
+++ libcfa/src/concurrency/io.cfa	(revision 428adbc385306e56a64258b0aab447c8dc5e0b6c)
@@ -610,5 +610,5 @@
 		if( we ) {
 			sigval_t value = { PREEMPT_IO };
-			pthread_sigqueue(ctx->proc->kernel_thread, SIGUSR1, value);
+			real_pthread_sigqueue(ctx->proc->kernel_thread, SIGUSR1, value);
 		}
 
Index: libcfa/src/concurrency/io/setup.cfa
===================================================================
--- libcfa/src/concurrency/io/setup.cfa	(revision 20be7824be588cb516b811f2b84e12e776350a51)
+++ libcfa/src/concurrency/io/setup.cfa	(revision 428adbc385306e56a64258b0aab447c8dc5e0b6c)
@@ -337,5 +337,5 @@
 	// 	iopoll.run = false;
 	// 	sigval val = { 1 };
-	// 	pthread_sigqueue( iopoll.thrd, SIGUSR1, val );
+	// 	real_pthread_sigqueue( iopoll.thrd, SIGUSR1, val );
 
 	// 	// Make sure all this is done
Index: libcfa/src/concurrency/preemption.cfa
===================================================================
--- libcfa/src/concurrency/preemption.cfa	(revision 20be7824be588cb516b811f2b84e12e776350a51)
+++ libcfa/src/concurrency/preemption.cfa	(revision 428adbc385306e56a64258b0aab447c8dc5e0b6c)
@@ -368,5 +368,5 @@
 	sigset_t oldset;
 	int ret;
-	ret = pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
+	ret = real_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
 	if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
 
@@ -401,5 +401,5 @@
 	sigaddset( &mask, sig );
 
-	if ( pthread_sigmask( SIG_UNBLOCK, &mask, 0p ) == -1 ) {
+	if ( real_pthread_sigmask( SIG_UNBLOCK, &mask, 0p ) == -1 ) {
 	    abort( "internal error, pthread_sigmask" );
 	}
@@ -412,5 +412,5 @@
 	sigaddset( &mask, sig );
 
-	if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
+	if ( real_pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
 		abort( "internal error, pthread_sigmask" );
 	}
@@ -420,5 +420,5 @@
 static void preempt( processor * this ) {
 	sigval_t value = { PREEMPT_NORMAL };
-	pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
+	real_pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
 }
 
@@ -431,5 +431,5 @@
 	sigset_t oldset;
 	int ret;
-	ret = pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
+	ret = real_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
 	if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
 
@@ -450,5 +450,5 @@
 	sigset_t oldset;
 	int ret;
-	ret = pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
+	ret = real_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
 	if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
 
@@ -608,5 +608,5 @@
 	sigval val;
 	val.sival_int = 0;
-	pthread_sigqueue( alarm_thread, SIGALRM, val );
+	real_pthread_sigqueue( alarm_thread, SIGALRM, val );
 
 	// Wait for the preemption thread to finish
@@ -682,5 +682,5 @@
 	static_assert( sizeof( sigset_t ) == sizeof( cxt->uc_sigmask ), "Expected cxt->uc_sigmask to be of sigset_t" );
 	#endif
-	if ( pthread_sigmask( SIG_SETMASK, (sigset_t *)&(cxt->uc_sigmask), 0p ) == -1 ) {
+	if ( real_pthread_sigmask( SIG_SETMASK, (sigset_t *)&(cxt->uc_sigmask), 0p ) == -1 ) {
 		abort( "internal error, sigprocmask" );
 	}
@@ -710,5 +710,5 @@
 	sigset_t mask;
 	sigfillset(&mask);
-	if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
+	if ( real_pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
 	    abort( "internal error, pthread_sigmask" );
 	}
Index: libcfa/src/concurrency/pthread.cfa
===================================================================
--- libcfa/src/concurrency/pthread.cfa	(revision 20be7824be588cb516b811f2b84e12e776350a51)
+++ libcfa/src/concurrency/pthread.cfa	(revision 428adbc385306e56a64258b0aab447c8dc5e0b6c)
@@ -666,7 +666,7 @@
 
 
-    // int pthread_sigmask( int /* how */, const sigset_t * /* set */, sigset_t * /* oset */ ) libcfa_public __THROW {
-	//     return 0;
-    // } // pthread_sigmask
+     int pthread_sigmask( int /* how */, const sigset_t * /* set */, sigset_t * /* oset */ ) libcfa_public __THROW {
+	     return 0;
+     } // pthread_sigmask
 
     int pthread_kill( pthread_t _thread __attribute__(( unused )), int sig ) libcfa_public __THROW {
@@ -679,7 +679,7 @@
     } // pthread_kill
 
-    // int pthread_sigqueue(pthread_t , int sig, const union sigval) libcfa_public __THROW {
-    //     return 0;
-    // } // pthread_sigqueue
+    int pthread_sigqueue(pthread_t , int sig, const union sigval) libcfa_public __THROW {
+        return 0;
+    } // pthread_sigqueue
 
     //######################### Scheduling #########################
Index: libcfa/src/interpose.cfa
===================================================================
--- libcfa/src/interpose.cfa	(revision 20be7824be588cb516b811f2b84e12e776350a51)
+++ libcfa/src/interpose.cfa	(revision 428adbc385306e56a64258b0aab447c8dc5e0b6c)
@@ -118,6 +118,6 @@
 	typeof(pthread_attr_destroy) pthread_attr_destroy;
 	typeof(pthread_attr_getstacksize) pthread_attr_getstacksize;
-	//typeof(pthread_sigmask) pthread_sigmask;
-	//typeof(pthread_sigqueue) pthread_sigqueue;
+	typeof(pthread_sigmask) pthread_sigmask;
+	typeof(pthread_sigqueue) pthread_sigqueue;
 } __cabi_libc;
 
@@ -142,6 +142,6 @@
 		INTERPOSE_LIBC( pthread_attr_setstack , version );
 		INTERPOSE_LIBC( pthread_attr_getstacksize , version );
-		//INTERPOSE_LIBC( pthread_sigmask , version );
-		//INTERPOSE_LIBC( pthread_sigqueue , version );
+		INTERPOSE_LIBC( pthread_sigmask , version );
+		INTERPOSE_LIBC( pthread_sigqueue , version );
 #pragma GCC diagnostic pop
 
@@ -229,10 +229,10 @@
 		return __cabi_libc.pthread_attr_getstacksize(attr, stacksize);
 	}
-	// libcfa_public int real_pthread_sigmask(int how, const sigset_t *set, sigset_t *oldset){
-	// 	return __cabi_libc.pthread_sigmask(how, set, oldset);
-	// }
-	// libcfa_public int real_pthread_sigqueue(pthread_t _thread, int sig, const union sigval value){
-	// 	return __cabi_libc.real_pthread_sigqueue(_thread, sig, value);
-	// }
+	libcfa_public int real_pthread_sigmask(int how, const sigset_t *set, sigset_t *oldset){
+		return __cabi_libc.pthread_sigmask(how, set, oldset);
+	}
+	libcfa_public int real_pthread_sigqueue(pthread_t _thread, int sig, const union sigval value){
+		return __cabi_libc.pthread_sigqueue(_thread, sig, value);
+	}
 }