Changes in / [135143b:df6cc9d]

Files:

• libcfa/src/Makefile.am (modified) (2 diffs)
• libcfa/src/concurrency/clib/cfathread.cfa (modified) (1 diff)
• libcfa/src/concurrency/io.cfa (modified) (1 diff)
• libcfa/src/concurrency/io/setup.cfa (modified) (1 diff)
• libcfa/src/concurrency/kernel/private.hfa (modified) (3 diffs)
• libcfa/src/concurrency/kernel/startup.cfa (modified) (5 diffs)
• libcfa/src/concurrency/preemption.cfa (modified) (9 diffs)
• libcfa/src/concurrency/pthread.cfa (added)
• libcfa/src/interpose.cfa (modified) (4 diffs)
• libcfa/src/interpose_thread.cfa (added)
• tests/concurrent/pthread/.expect/bounded_buffer.txt (added)
• tests/concurrent/pthread/.expect/pthread_attr_test.txt (added)
• tests/concurrent/pthread/.expect/pthread_cond_test.txt (added)
• tests/concurrent/pthread/.expect/pthread_demo_create_join.txt (added)
• tests/concurrent/pthread/.expect/pthread_demo_lock.txt (added)
• tests/concurrent/pthread/.expect/pthread_key_test.txt (added)
• tests/concurrent/pthread/.expect/pthread_once_test.txt (added)
• tests/concurrent/pthread/bounded_buffer.cfa (added)
• tests/concurrent/pthread/pthread_attr_test.cfa (added)
• tests/concurrent/pthread/pthread_cond_test.cfa (added)
• tests/concurrent/pthread/pthread_demo_create_join.cfa (added)
• tests/concurrent/pthread/pthread_demo_lock.cfa (added)
• tests/concurrent/pthread/pthread_key_test.cfa (added)
• tests/concurrent/pthread/pthread_once_test.cfa (added)

libcfa/src/Makefile.am

@@ -127 +127 @@
 
 thread_libsrc = ${inst_thread_headers_src} ${inst_thread_headers_src:.hfa=.cfa} \
+        interpose_thread.cfa \
         bits/signal.hfa \
         concurrency/clib/cfathread.cfa \
@@ -145 +146 @@
         concurrency/stats.cfa \
         concurrency/stats.hfa \
-        concurrency/stats.hfa
+        concurrency/stats.hfa \
+        concurrency/pthread.cfa
 
 else

libcfa/src/concurrency/clib/cfathread.cfa

@@ -172 +172 @@
 
                 pthread_attr_t attr;
-                if (int ret = pthread_attr_init(&attr); 0 != ret) {
+                if (int ret = __cfaabi_pthread_attr_init(&attr); 0 != ret) {
                         abort | "failed to create master epoll thread attr: " | ret | strerror(ret);
                 }
 
-                if (int ret = pthread_create(&master_poller, &attr, master_epoll, 0p); 0 != ret) {
+                if (int ret = __cfaabi_pthread_create(&master_poller, &attr, master_epoll, 0p); 0 != ret) {
                         abort | "failed to create master epoll thread: " | ret | strerror(ret);
                 }

libcfa/src/concurrency/io.cfa

@@ -610 +610 @@
                 if( we ) {
                         sigval_t value = { PREEMPT_IO };
-                        pthread_sigqueue(ctx->proc->kernel_thread, SIGUSR1, value);
+                        __cfaabi_pthread_sigqueue(ctx->proc->kernel_thread, SIGUSR1, value);
                 }
 

libcfa/src/concurrency/io/setup.cfa

@@ -344 +344 @@
         //      iopoll.run = false;
         //      sigval val = { 1 };
-        //      pthread_sigqueue( iopoll.thrd, SIGUSR1, val );
+        //      __cfaabi_pthread_sigqueue( iopoll.thrd, SIGUSR1, val );
 
         //      // Make sure all this is done

libcfa/src/concurrency/kernel/private.hfa

@@ -20 +20 @@
 #endif
 
+#include <signal.h>
+
 #include "kernel.hfa"
 #include "thread.hfa"
@@ -48 +50 @@
         #endif
 #endif
-
 // #define READYQ_USE_LINEAR_AVG
 #define READYQ_USE_LOGDBL_AVG
@@ -62 +63 @@
 #error must pick a scheme for averaging
 #endif
+
+extern "C" {
+        __attribute__((visibility("protected"))) int __cfaabi_pthread_create(pthread_t *_thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
+        __attribute__((visibility("protected"))) int __cfaabi_pthread_join(pthread_t _thread, void **retval);
+        __attribute__((visibility("protected"))) pthread_t __cfaabi_pthread_self(void);
+        __attribute__((visibility("protected"))) int __cfaabi_pthread_attr_init(pthread_attr_t *attr);
+        __attribute__((visibility("protected"))) int __cfaabi_pthread_attr_destroy(pthread_attr_t *attr);
+        __attribute__((visibility("protected"))) int __cfaabi_pthread_attr_setstack( pthread_attr_t *attr, void *stackaddr, size_t stacksize );
+        __attribute__((visibility("protected"))) int __cfaabi_pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize );
+        __attribute__((visibility("protected"))) int __cfaabi_pthread_sigqueue(pthread_t _thread, int sig, const union sigval value);
+        __attribute__((visibility("protected"))) int __cfaabi_pthread_sigmask( int how, const sigset_t *set, sigset_t *oset);
+}
 
 //-----------------------------------------------------------------------------

libcfa/src/concurrency/kernel/startup.cfa

@@ -222 +222 @@
                 ( this.runner ){};
                 init( this, "Main Processor", *mainCluster, 0p );
-                kernel_thread = pthread_self();
+                kernel_thread = __cfaabi_pthread_self();
 
                 runner{ &this };
@@ -283 +283 @@
 }
 
+extern "C"{
+        void pthread_delete_kernel_threads_();
+}
+
+
 static void __kernel_shutdown(void) {
         if(!cfa_main_returned) return;
+
+        //delete kernel threads for pthread_concurrency
+        pthread_delete_kernel_threads_();
+
         /* paranoid */ verify( __preemption_enabled() );
         disable_interrupts();
@@ -777 +786 @@
         pthread_attr_t attr;
 
-        check( pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
+        check( __cfaabi_pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
 
         size_t stacksize = max( PTHREAD_STACK_MIN, DEFAULT_STACK_SIZE );
@@ -804 +813 @@
         #endif
 
-        check( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
-        check( pthread_create( pthread, &attr, start, arg ), "pthread_create" );
+        check( __cfaabi_pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
+        check( __cfaabi_pthread_create( pthread, &attr, start, arg ), "pthread_create" );
         return stack;
 }
 
 void __destroy_pthread( pthread_t pthread, void * stack, void ** retval ) {
-        int err = pthread_join( pthread, retval );
+        int err = __cfaabi_pthread_join( pthread, retval );
         if( err != 0 ) abort("KERNEL ERROR: joining pthread %p caused error %s\n", (void*)pthread, strerror(err));
 
@@ -816 +825 @@
                 pthread_attr_t attr;
 
-                check( pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
+                check( __cfaabi_pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
 
                 size_t stacksize;
                 // default stack size, normally defined by shell limit
-                check( pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
+                check( __cfaabi_pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
                 assert( stacksize >= PTHREAD_STACK_MIN );
                 stacksize += __page_size;

libcfa/src/concurrency/preemption.cfa

@@ -352 +352 @@
         sigset_t oldset;
         int ret;
-        ret = pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
+        ret = __cfaabi_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
         if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
 
@@ -385 +385 @@
         sigaddset( &mask, sig );
 
-        if ( pthread_sigmask( SIG_UNBLOCK, &mask, 0p ) == -1 ) {
+        if ( __cfaabi_pthread_sigmask( SIG_UNBLOCK, &mask, 0p ) == -1 ) {
             abort( "internal error, pthread_sigmask" );
         }
@@ -396 +396 @@
         sigaddset( &mask, sig );
 
-        if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
+        if ( __cfaabi_pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
                 abort( "internal error, pthread_sigmask" );
         }
@@ -404 +404 @@
 static void preempt( processor * this ) {
         sigval_t value = { PREEMPT_NORMAL };
-        pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
+        __cfaabi_pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
 }
 
@@ -415 +415 @@
         sigset_t oldset;
         int ret;
-        ret = pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
+        ret = __cfaabi_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
         if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
 
@@ -434 +434 @@
         sigset_t oldset;
         int ret;
-        ret = pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
+        ret = __cfaabi_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
         if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
 
@@ -505 +505 @@
         sigval val;
         val.sival_int = 0;
-        pthread_sigqueue( alarm_thread, SIGALRM, val );
+        __cfaabi_pthread_sigqueue( alarm_thread, SIGALRM, val );
 
         // Wait for the preemption thread to finish
@@ -579 +579 @@
         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 ( __cfaabi_pthread_sigmask( SIG_SETMASK, (sigset_t *)&(cxt->uc_sigmask), 0p ) == -1 ) {
                 abort( "internal error, sigprocmask" );
         }
@@ -607 +607 @@
         sigset_t mask;
         sigfillset(&mask);
-        if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
+        if ( __cfaabi_pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
             abort( "internal error, pthread_sigmask" );
         }

libcfa/src/interpose.cfa

@@ -42 +42 @@
 
 typedef void (* generic_fptr_t)(void);
+static generic_fptr_t do_interpose_symbol( void * library, const char symbol[], const char version[] ) {
+        const char * error;
+
+        union { generic_fptr_t fptr; void * ptr; } originalFunc;
+
+        #if defined( _GNU_SOURCE )
+                if ( version ) {
+                        originalFunc.ptr = dlvsym( library, symbol, version );
+                } else {
+                        originalFunc.ptr = dlsym( library, symbol );
+                }
+        #else
+                originalFunc.ptr = dlsym( library, symbol );
+        #endif // _GNU_SOURCE
+
+        error = dlerror();
+        if ( error ) abort( "interpose_symbol : internal error, %s\n", error );
+
+        return originalFunc.fptr;
+}
+
 static generic_fptr_t interpose_symbol( const char symbol[], const char version[] ) {
         const char * error;
 
         static void * library;
+        static void * pthread_library;
         if ( ! library ) {
                 #if defined( RTLD_NEXT )
@@ -58 +80 @@
                 #endif
         } // if
-
-        union { generic_fptr_t fptr; void * ptr; } originalFunc;
-
-        #if defined( _GNU_SOURCE )
-                if ( version ) {
-                        originalFunc.ptr = dlvsym( library, symbol, version );
-                } else {
-                        originalFunc.ptr = dlsym( library, symbol );
-                }
-        #else
-                originalFunc.ptr = dlsym( library, symbol );
-        #endif // _GNU_SOURCE
-
-        error = dlerror();
-        if ( error ) abort( "interpose_symbol : internal error, %s\n", error );
-
-        return originalFunc.fptr;
+        if ( ! pthread_library ) {
+                #if defined( RTLD_NEXT )
+                        pthread_library = RTLD_NEXT;
+                #else
+                        // missing RTLD_NEXT => must hard-code library name, assuming libstdc++
+                        pthread_library = dlopen( "libpthread.so", RTLD_LAZY );
+                        error = dlerror();
+                        if ( error ) {
+                                abort( "interpose_symbol : failed to open libpthread, %s\n", error );
+                        }
+                #endif
+        } // if
+
+        return do_interpose_symbol(library, symbol, version);
 }
 
@@ -97 +116 @@
 
 extern "C" {
+        void __cfathreadabi_interpose_startup( generic_fptr_t (*do_interpose_symbol)( void * library, const char symbol[], const char version[] ) ) __attribute__((weak));
         void __cfaabi_interpose_startup( void ) {
                 const char *version = 0p;
@@ -108 +128 @@
                 INTERPOSE_LIBC( exit , version );
 #pragma GCC diagnostic pop
+
+                if(__cfathreadabi_interpose_startup) __cfathreadabi_interpose_startup( do_interpose_symbol );
 
                 // As a precaution (and necessity), errors that result in termination are delivered on a separate stack because