Ignore:
Timestamp:
Sep 21, 2022, 11:56:16 AM (2 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, ast-experimental, master, pthread-emulation
Children:
9cd5bd2
Parents:
7f6a7c9
Message:

Changed real_pthread symbols (now cfaabi_pthread) to be protected in libcfathread

Location:
libcfa/src/concurrency
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/concurrency/clib/cfathread.cfa

    r7f6a7c9 r95dab9e  
    172172
    173173                pthread_attr_t attr;
    174                 if (int ret = real_pthread_attr_init(&attr); 0 != ret) {
     174                if (int ret = __cfaabi_pthread_attr_init(&attr); 0 != ret) {
    175175                        abort | "failed to create master epoll thread attr: " | ret | strerror(ret);
    176176                }
    177177
    178                 if (int ret = real_pthread_create(&master_poller, &attr, master_epoll, 0p); 0 != ret) {
     178                if (int ret = __cfaabi_pthread_create(&master_poller, &attr, master_epoll, 0p); 0 != ret) {
    179179                        abort | "failed to create master epoll thread: " | ret | strerror(ret);
    180180                }
  • libcfa/src/concurrency/io.cfa

    r7f6a7c9 r95dab9e  
    610610                if( we ) {
    611611                        sigval_t value = { PREEMPT_IO };
    612                         real_pthread_sigqueue(ctx->proc->kernel_thread, SIGUSR1, value);
     612                        __cfaabi_pthread_sigqueue(ctx->proc->kernel_thread, SIGUSR1, value);
    613613                }
    614614
  • libcfa/src/concurrency/io/setup.cfa

    r7f6a7c9 r95dab9e  
    344344        //      iopoll.run = false;
    345345        //      sigval val = { 1 };
    346         //      real_pthread_sigqueue( iopoll.thrd, SIGUSR1, val );
     346        //      __cfaabi_pthread_sigqueue( iopoll.thrd, SIGUSR1, val );
    347347
    348348        //      // Make sure all this is done
  • libcfa/src/concurrency/kernel/private.hfa

    r7f6a7c9 r95dab9e  
    4949#endif
    5050
     51extern "C" {
     52        __attribute__((visibility("protected"))) int __cfaabi_pthread_create(pthread_t *_thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
     53        __attribute__((visibility("protected"))) int __cfaabi_pthread_join(pthread_t _thread, void **retval);
     54        __attribute__((visibility("protected"))) pthread_t __cfaabi_pthread_self(void);
     55        __attribute__((visibility("protected"))) int __cfaabi_pthread_attr_init(pthread_attr_t *attr);
     56        __attribute__((visibility("protected"))) int __cfaabi_pthread_attr_destroy(pthread_attr_t *attr);
     57        __attribute__((visibility("protected"))) int __cfaabi_pthread_attr_setstack( pthread_attr_t *attr, void *stackaddr, size_t stacksize );
     58        __attribute__((visibility("protected"))) int __cfaabi_pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize );
     59        __attribute__((visibility("protected"))) int __cfaabi_pthread_sigqueue(pthread_t _thread, int sig, const union sigval value);
     60        __attribute__((visibility("protected"))) int __cfaabi_pthread_sigmask( int how, const sigset_t *set, sigset_t *oset);
     61}
     62
    5163//-----------------------------------------------------------------------------
    5264// Scheduler
  • libcfa/src/concurrency/kernel/startup.cfa

    r7f6a7c9 r95dab9e  
    219219                ( this.runner ){};
    220220                init( this, "Main Processor", *mainCluster, 0p );
    221                 kernel_thread = real_pthread_self();
     221                kernel_thread = __cfaabi_pthread_self();
    222222
    223223                runner{ &this };
     
    779779        pthread_attr_t attr;
    780780
    781         check( real_pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
     781        check( __cfaabi_pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
    782782
    783783        size_t stacksize = max( PTHREAD_STACK_MIN, DEFAULT_STACK_SIZE );
     
    806806        #endif
    807807
    808         check( real_pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
    809         check( real_pthread_create( pthread, &attr, start, arg ), "pthread_create" );
     808        check( __cfaabi_pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
     809        check( __cfaabi_pthread_create( pthread, &attr, start, arg ), "pthread_create" );
    810810        return stack;
    811811}
    812812
    813813void __destroy_pthread( pthread_t pthread, void * stack, void ** retval ) {
    814         int err = real_pthread_join( pthread, retval );
     814        int err = __cfaabi_pthread_join( pthread, retval );
    815815        if( err != 0 ) abort("KERNEL ERROR: joining pthread %p caused error %s\n", (void*)pthread, strerror(err));
    816816
     
    818818                pthread_attr_t attr;
    819819
    820                 check( real_pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
     820                check( __cfaabi_pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
    821821
    822822                size_t stacksize;
    823823                // default stack size, normally defined by shell limit
    824                 check( real_pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
     824                check( __cfaabi_pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
    825825                assert( stacksize >= PTHREAD_STACK_MIN );
    826826                stacksize += __page_size;
  • libcfa/src/concurrency/preemption.cfa

    r7f6a7c9 r95dab9e  
    406406        sigset_t oldset;
    407407        int ret;
    408         ret = real_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
     408        ret = __cfaabi_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
    409409        if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
    410410
     
    439439        sigaddset( &mask, sig );
    440440
    441         if ( real_pthread_sigmask( SIG_UNBLOCK, &mask, 0p ) == -1 ) {
     441        if ( __cfaabi_pthread_sigmask( SIG_UNBLOCK, &mask, 0p ) == -1 ) {
    442442            abort( "internal error, pthread_sigmask" );
    443443        }
     
    450450        sigaddset( &mask, sig );
    451451
    452         if ( real_pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
     452        if ( __cfaabi_pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
    453453                abort( "internal error, pthread_sigmask" );
    454454        }
     
    458458static void preempt( processor * this ) {
    459459        sigval_t value = { PREEMPT_NORMAL };
    460         real_pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
     460        __cfaabi_pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
    461461}
    462462
     
    469469        sigset_t oldset;
    470470        int ret;
    471         ret = real_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
     471        ret = __cfaabi_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
    472472        if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
    473473
     
    488488        sigset_t oldset;
    489489        int ret;
    490         ret = real_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
     490        ret = __cfaabi_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
    491491        if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
    492492
     
    559559        sigval val;
    560560        val.sival_int = 0;
    561         real_pthread_sigqueue( alarm_thread, SIGALRM, val );
     561        __cfaabi_pthread_sigqueue( alarm_thread, SIGALRM, val );
    562562
    563563        // Wait for the preemption thread to finish
     
    633633        static_assert( sizeof( sigset_t ) == sizeof( cxt->uc_sigmask ), "Expected cxt->uc_sigmask to be of sigset_t" );
    634634        #endif
    635         if ( real_pthread_sigmask( SIG_SETMASK, (sigset_t *)&(cxt->uc_sigmask), 0p ) == -1 ) {
     635        if ( __cfaabi_pthread_sigmask( SIG_SETMASK, (sigset_t *)&(cxt->uc_sigmask), 0p ) == -1 ) {
    636636                abort( "internal error, sigprocmask" );
    637637        }
     
    661661        sigset_t mask;
    662662        sigfillset(&mask);
    663         if ( real_pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
     663        if ( __cfaabi_pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
    664664            abort( "internal error, pthread_sigmask" );
    665665        }
Note: See TracChangeset for help on using the changeset viewer.