Index: libcfa/src/Makefile.am =================================================================== --- libcfa/src/Makefile.am (revision 7f6a7c9815ca57db7bd45062dda4b61c275ad2ec) +++ libcfa/src/Makefile.am (revision 95dab9ec006307c04669f1d2832d144a7ff5a92f) @@ -124,7 +124,8 @@ concurrency/monitor.hfa \ concurrency/mutex.hfa \ - concurrency/thread.hfa + concurrency/thread.hfa thread_libsrc = ${inst_thread_headers_src} ${inst_thread_headers_src:.hfa=.cfa} \ + interpose_thread.cfa \ bits/signal.hfa \ concurrency/clib/cfathread.cfa \ Index: libcfa/src/bits/defs.hfa =================================================================== --- libcfa/src/bits/defs.hfa (revision 7f6a7c9815ca57db7bd45062dda4b61c275ad2ec) +++ libcfa/src/bits/defs.hfa (revision 95dab9ec006307c04669f1d2832d144a7ff5a92f) @@ -59,15 +59,5 @@ void abort( bool signalAbort, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ )); extern "C" { - #include - void __cabi_abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )); - int real_pthread_create(pthread_t *_thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg); - int real_pthread_join(pthread_t _thread, void **retval); - pthread_t real_pthread_self(void); - int real_pthread_attr_init(pthread_attr_t *attr); - int real_pthread_attr_destroy(pthread_attr_t *attr); - 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); +void __cabi_abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )); } #endif Index: libcfa/src/concurrency/clib/cfathread.cfa =================================================================== --- libcfa/src/concurrency/clib/cfathread.cfa (revision 7f6a7c9815ca57db7bd45062dda4b61c275ad2ec) +++ libcfa/src/concurrency/clib/cfathread.cfa (revision 95dab9ec006307c04669f1d2832d144a7ff5a92f) @@ -172,9 +172,9 @@ pthread_attr_t attr; - if (int ret = real_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 = real_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); } Index: libcfa/src/concurrency/io.cfa =================================================================== --- libcfa/src/concurrency/io.cfa (revision 7f6a7c9815ca57db7bd45062dda4b61c275ad2ec) +++ libcfa/src/concurrency/io.cfa (revision 95dab9ec006307c04669f1d2832d144a7ff5a92f) @@ -610,5 +610,5 @@ if( we ) { sigval_t value = { PREEMPT_IO }; - real_pthread_sigqueue(ctx->proc->kernel_thread, SIGUSR1, value); + __cfaabi_pthread_sigqueue(ctx->proc->kernel_thread, SIGUSR1, value); } Index: libcfa/src/concurrency/io/setup.cfa =================================================================== --- libcfa/src/concurrency/io/setup.cfa (revision 7f6a7c9815ca57db7bd45062dda4b61c275ad2ec) +++ libcfa/src/concurrency/io/setup.cfa (revision 95dab9ec006307c04669f1d2832d144a7ff5a92f) @@ -344,5 +344,5 @@ // iopoll.run = false; // sigval val = { 1 }; - // real_pthread_sigqueue( iopoll.thrd, SIGUSR1, val ); + // __cfaabi_pthread_sigqueue( iopoll.thrd, SIGUSR1, val ); // // Make sure all this is done Index: libcfa/src/concurrency/kernel/private.hfa =================================================================== --- libcfa/src/concurrency/kernel/private.hfa (revision 7f6a7c9815ca57db7bd45062dda4b61c275ad2ec) +++ libcfa/src/concurrency/kernel/private.hfa (revision 95dab9ec006307c04669f1d2832d144a7ff5a92f) @@ -49,4 +49,16 @@ #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); +} + //----------------------------------------------------------------------------- // Scheduler Index: libcfa/src/concurrency/kernel/startup.cfa =================================================================== --- libcfa/src/concurrency/kernel/startup.cfa (revision 7f6a7c9815ca57db7bd45062dda4b61c275ad2ec) +++ libcfa/src/concurrency/kernel/startup.cfa (revision 95dab9ec006307c04669f1d2832d144a7ff5a92f) @@ -219,5 +219,5 @@ ( this.runner ){}; init( this, "Main Processor", *mainCluster, 0p ); - kernel_thread = real_pthread_self(); + kernel_thread = __cfaabi_pthread_self(); runner{ &this }; @@ -779,5 +779,5 @@ pthread_attr_t attr; - check( real_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 ); @@ -806,11 +806,11 @@ #endif - check( real_pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" ); - check( real_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 = real_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)); @@ -818,9 +818,9 @@ pthread_attr_t attr; - check( real_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( real_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; Index: libcfa/src/concurrency/preemption.cfa =================================================================== --- libcfa/src/concurrency/preemption.cfa (revision 7f6a7c9815ca57db7bd45062dda4b61c275ad2ec) +++ libcfa/src/concurrency/preemption.cfa (revision 95dab9ec006307c04669f1d2832d144a7ff5a92f) @@ -406,5 +406,5 @@ sigset_t oldset; int ret; - ret = real_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); } @@ -439,5 +439,5 @@ sigaddset( &mask, sig ); - if ( real_pthread_sigmask( SIG_UNBLOCK, &mask, 0p ) == -1 ) { + if ( __cfaabi_pthread_sigmask( SIG_UNBLOCK, &mask, 0p ) == -1 ) { abort( "internal error, pthread_sigmask" ); } @@ -450,5 +450,5 @@ sigaddset( &mask, sig ); - if ( real_pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) { + if ( __cfaabi_pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) { abort( "internal error, pthread_sigmask" ); } @@ -458,5 +458,5 @@ static void preempt( processor * this ) { sigval_t value = { PREEMPT_NORMAL }; - real_pthread_sigqueue( this->kernel_thread, SIGUSR1, value ); + __cfaabi_pthread_sigqueue( this->kernel_thread, SIGUSR1, value ); } @@ -469,5 +469,5 @@ sigset_t oldset; int ret; - ret = real_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); } @@ -488,5 +488,5 @@ sigset_t oldset; int ret; - ret = real_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); } @@ -559,5 +559,5 @@ sigval val; val.sival_int = 0; - real_pthread_sigqueue( alarm_thread, SIGALRM, val ); + __cfaabi_pthread_sigqueue( alarm_thread, SIGALRM, val ); // Wait for the preemption thread to finish @@ -633,5 +633,5 @@ static_assert( sizeof( sigset_t ) == sizeof( cxt->uc_sigmask ), "Expected cxt->uc_sigmask to be of sigset_t" ); #endif - if ( real_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" ); } @@ -661,5 +661,5 @@ sigset_t mask; sigfillset(&mask); - if ( real_pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) { + if ( __cfaabi_pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) { abort( "internal error, pthread_sigmask" ); } Index: libcfa/src/interpose.cfa =================================================================== --- libcfa/src/interpose.cfa (revision 7f6a7c9815ca57db7bd45062dda4b61c275ad2ec) +++ libcfa/src/interpose.cfa (revision 95dab9ec006307c04669f1d2832d144a7ff5a92f) @@ -42,4 +42,25 @@ 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; @@ -72,26 +93,5 @@ } // 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 ) { - originalFunc.ptr = dlsym( pthread_library, symbol ); - error = dlerror(); - if (error){ - abort( "interpose_symbol : internal error, %s\n", error ); - } // if - } // if - - return originalFunc.fptr; + return do_interpose_symbol(library, symbol, version); } @@ -111,13 +111,13 @@ void (* exit)( int ) __attribute__(( __noreturn__ )); void (* abort)( void ) __attribute__(( __noreturn__ )); - typeof(pthread_create) pthread_create; - typeof(pthread_join) pthread_join; - typeof(pthread_self) pthread_self; - typeof(pthread_attr_init) pthread_attr_init; - typeof(pthread_attr_setstack ) pthread_attr_setstack; - typeof(pthread_attr_destroy) pthread_attr_destroy; - typeof(pthread_attr_getstacksize) pthread_attr_getstacksize; - typeof(pthread_sigmask) pthread_sigmask; - typeof(pthread_sigqueue) pthread_sigqueue; + int (*pthread_create)(pthread_t *_thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg); + int (*pthread_join)(pthread_t _thread, void **retval); + pthread_t (*pthread_self)(void); + int (*pthread_attr_init)(pthread_attr_t *attr); + int (*pthread_attr_destroy)(pthread_attr_t *attr); + int (*pthread_attr_setstack)( pthread_attr_t *attr, void *stackaddr, size_t stacksize ); + int (*pthread_attr_getstacksize)( const pthread_attr_t *attr, size_t *stacksize ); + int (*pthread_sigmask)(int how, const sigset_t *set, sigset_t *oldset); + int (*pthread_sigqueue)(pthread_t _thread, int sig, const union sigval value); } __cabi_libc; @@ -125,4 +125,5 @@ 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; @@ -135,14 +136,7 @@ INTERPOSE_LIBC( abort, version ); INTERPOSE_LIBC( exit , version ); - INTERPOSE_LIBC( pthread_create , version ); - INTERPOSE_LIBC( pthread_join , version ); - INTERPOSE_LIBC( pthread_self , version ); - INTERPOSE_LIBC( pthread_attr_init , version ); - INTERPOSE_LIBC( pthread_attr_destroy , version ); - INTERPOSE_LIBC( pthread_attr_setstack , version ); - INTERPOSE_LIBC( pthread_attr_getstacksize , version ); - INTERPOSE_LIBC( pthread_sigmask , version ); - INTERPOSE_LIBC( pthread_sigqueue , 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 @@ -204,34 +198,4 @@ libcfa_public void exit( int status ) __attribute__(( __nothrow__, __leaf__, __noreturn__ )) { __cabi_libc.exit( status ); - } - - libcfa_public int real_pthread_create(pthread_t *_thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg){ - return __cabi_libc.pthread_create(_thread, attr, start_routine, arg); - } - - libcfa_public int real_pthread_join(pthread_t _thread, void **retval){ - return __cabi_libc.pthread_join(_thread, retval); - } - - libcfa_public pthread_t real_pthread_self(void){ - return __cabi_libc.pthread_self(); - } - libcfa_public int real_pthread_attr_init(pthread_attr_t *attr){ - return __cabi_libc.pthread_attr_init(attr); - } - libcfa_public int real_pthread_attr_destroy(pthread_attr_t *attr){ - return __cabi_libc.pthread_attr_destroy(attr); - } - libcfa_public int real_pthread_attr_setstack( pthread_attr_t *attr, void *stackaddr, size_t stacksize ){ - return __cabi_libc.pthread_attr_setstack(attr, stackaddr, stacksize); - } - libcfa_public int read_pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize ){ - 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.pthread_sigqueue(_thread, sig, value); } } Index: libcfa/src/interpose_thread.cfa =================================================================== --- libcfa/src/interpose_thread.cfa (revision 95dab9ec006307c04669f1d2832d144a7ff5a92f) +++ libcfa/src/interpose_thread.cfa (revision 95dab9ec006307c04669f1d2832d144a7ff5a92f) @@ -0,0 +1,123 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2022 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// interpose_thread.c -- +// +// Author : Thierry Delisle +// Created On : Wed Sep 21 11:55:16 2022 +// Last Modified By : +// Last Modified On : +// Update Count : +// + +#include // va_start, va_end +#include +#include // strlen +extern "C" { +#include // dlopen, dlsym +#include // backtrace, messages +} + +#include "bits/debug.hfa" +#include "bits/defs.hfa" +#include + +//============================================================================================= +// Interposing helpers +//============================================================================================= + +typedef void (* generic_fptr_t)(void); + +generic_fptr_t interpose_symbol( + generic_fptr_t (*do_interpose_symbol)( void * library, const char symbol[], const char version[] ), + const char symbol[], + const char version[] +) libcfa_public { + const char * error; + + static void * library; + if ( ! library ) { + #if defined( RTLD_NEXT ) + library = RTLD_NEXT; + #else + // missing RTLD_NEXT => must hard-code library name, assuming libstdc++ + 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); +} + +#define INTERPOSE( x, ver ) __cabi_libpthread.x = (typeof(__cabi_libpthread.x))interpose_symbol( do_interpose_symbol, #x, ver ) + +//============================================================================================= +// Interposition Startup logic +//============================================================================================= + +static struct { + int (*pthread_create)(pthread_t *_thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg); + int (*pthread_join)(pthread_t _thread, void **retval); + pthread_t (*pthread_self)(void); + int (*pthread_attr_init)(pthread_attr_t *attr); + int (*pthread_attr_destroy)(pthread_attr_t *attr); + int (*pthread_attr_setstack)( pthread_attr_t *attr, void *stackaddr, size_t stacksize ); + int (*pthread_attr_getstacksize)( const pthread_attr_t *attr, size_t *stacksize ); + int (*pthread_sigmask)(int how, const sigset_t *set, sigset_t *oldset); + int (*pthread_sigqueue)(pthread_t _thread, int sig, const union sigval value); +} __cabi_libpthread; + +extern "C" { + void __cfathreadabi_interpose_startup( generic_fptr_t (*do_interpose_symbol)( void * library, const char symbol[], const char version[] ) ) libcfa_public { + const char *version = 0p; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdiscarded-qualifiers" + INTERPOSE( pthread_create , version ); + INTERPOSE( pthread_join , version ); + INTERPOSE( pthread_self , version ); + INTERPOSE( pthread_attr_init , version ); + INTERPOSE( pthread_attr_destroy , version ); + INTERPOSE( pthread_attr_setstack , version ); + INTERPOSE( pthread_attr_getstacksize , version ); + INTERPOSE( pthread_sigmask , version ); + INTERPOSE( pthread_sigqueue , version ); +#pragma GCC diagnostic pop + } + + int __cfaabi_pthread_create(pthread_t *_thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg){ + return __cabi_libpthread.pthread_create(_thread, attr, start_routine, arg); + } + + int __cfaabi_pthread_join(pthread_t _thread, void **retval){ + return __cabi_libpthread.pthread_join(_thread, retval); + } + + pthread_t __cfaabi_pthread_self(void){ + return __cabi_libpthread.pthread_self(); + } + int __cfaabi_pthread_attr_init(pthread_attr_t *attr){ + return __cabi_libpthread.pthread_attr_init(attr); + } + int __cfaabi_pthread_attr_destroy(pthread_attr_t *attr){ + return __cabi_libpthread.pthread_attr_destroy(attr); + } + int __cfaabi_pthread_attr_setstack( pthread_attr_t *attr, void *stackaddr, size_t stacksize ){ + return __cabi_libpthread.pthread_attr_setstack(attr, stackaddr, stacksize); + } + int read_pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize ){ + return __cabi_libpthread.pthread_attr_getstacksize(attr, stacksize); + } + int __cfaabi_pthread_sigmask(int how, const sigset_t *set, sigset_t *oldset){ + return __cabi_libpthread.pthread_sigmask(how, set, oldset); + } + int __cfaabi_pthread_sigqueue(pthread_t _thread, int sig, const union sigval value){ + return __cabi_libpthread.pthread_sigqueue(_thread, sig, value); + } +}