Changes in / [6f302cd:8633485b]


Ignore:
Location:
libcfa/src
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/bits/defs.hfa

    r6f302cd r8633485b  
    1010// Created On       : Thu Nov  9 13:24:10 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jan 28 22:38:27 2020
    13 // Update Count     : 9
     12// Last Modified On : Thu Feb  8 16:22:41 2018
     13// Update Count     : 8
    1414//
    1515
    … …  
    3434
    3535#ifdef __cforall
    36 void abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
    37 void abort( bool signalAbort, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
     36void abort ( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
    3837extern "C" {
    3938#endif

  • libcfa/src/bits/signal.hfa

    r6f302cd r8633485b  
    4040        sigaddset( &act.sa_mask, SIGALRM );             // disabled during signal handler
    4141        sigaddset( &act.sa_mask, SIGUSR1 );
    42         sigaddset( &act.sa_mask, SIGSEGV );
    43         sigaddset( &act.sa_mask, SIGBUS );
    44         sigaddset( &act.sa_mask, SIGILL );
    45         sigaddset( &act.sa_mask, SIGFPE );
    46         sigaddset( &act.sa_mask, SIGHUP );              // revert to default on second delivery
    47         sigaddset( &act.sa_mask, SIGTERM );
    48         sigaddset( &act.sa_mask, SIGINT );
    4942        act.sa_flags = flags;
    5043
    51         if ( sigaction( sig, &act, 0p ) == -1 ) {
     44        if ( sigaction( sig, &act, NULL ) == -1 ) {
    5245                __cfaabi_dbg_print_buffer_decl(
    5346                        " __cfaabi_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n",
    … …  
    5548                );
    5649                _exit( EXIT_FAILURE );
    57         } // if
     50        }
    5851}
     52
     53// Sigaction wrapper : restore default handler
     54static void __cfaabi_sigdefault( int sig ) {
     55        struct sigaction act;
     56
     57        act.sa_handler = SIG_DFL;
     58        act.sa_flags = 0;
     59        sigemptyset( &act.sa_mask );
     60
     61        if ( sigaction( sig, &act, NULL ) == -1 ) {
     62                __cfaabi_dbg_print_buffer_decl(
     63                        " __cfaabi_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n",
     64                        sig, errno, strerror( errno )
     65                );
     66                _exit( EXIT_FAILURE );
     67        }
     68}

  • libcfa/src/concurrency/kernel.cfa

    r6f302cd r8633485b  
    1010// Created On       : Tue Jan 17 12:27:26 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jan 30 22:55:50 2020
    13 // Update Count     : 56
     12// Last Modified On : Thu Dec  5 16:25:52 2019
     13// Update Count     : 52
    1414//
    1515
    … …  
    841841                sigemptyset( &mask );
    842842                sigaddset( &mask, SIGALRM );            // block SIGALRM signals
    843                 sigaddset( &mask, SIGUSR1 );            // block SIGALRM signals
    844                 sigsuspend( &mask );                            // block the processor to prevent further damage during abort
    845                 _exit( EXIT_FAILURE );                          // if processor unblocks before it is killed, terminate it
     843                sigsuspend( &mask );                    // block the processor to prevent further damage during abort
     844                _exit( EXIT_FAILURE );                  // if processor unblocks before it is killed, terminate it
    846845        }
    847846        else {

  • libcfa/src/interpose.cfa

    r6f302cd r8633485b  
    1010// Created On       : Wed Mar 29 16:10:31 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jan 30 17:47:32 2020
    13 // Update Count     : 156
     12// Last Modified On : Fri Dec 13 13:45:21 2019
     13// Update Count     : 121
    1414//
    1515
    … …  
    9595        void __cfaabi_interpose_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_CORE ) ));
    9696        void __cfaabi_interpose_startup( void ) {
    97                 const char *version = 0p;
     97                const char *version = NULL;
    9898
    9999                preload_libgcc();
    … …  
    105105#pragma GCC diagnostic pop
    106106
    107                 // As a precaution (and necessity), errors that result in termination are delivered on a separate stack because
    108                 // task stacks might be very small (4K) and the signal delivery corrupts memory to the point that a clean
    109                 // shutdown is impossible. Also, when a stack overflow encounters the non-accessible sentinel page (debug only)
    110                 // and generates a segment fault, the signal cannot be delivered on the sentinel page. Finally, calls to abort
    111                 // print a stack trace that uses substantial stack space.
    112 
    113                 #define MINSTKSZ SIGSTKSZ * 8
    114                 static char stack[MINSTKSZ] __attribute__(( aligned (16) ));
    115                 static stack_t ss;
    116 
    117                 ss.ss_sp = stack;
    118                 ss.ss_size = MINSTKSZ;
    119                 ss.ss_flags = 0;
    120                 if ( sigaltstack( &ss, 0p ) == -1 ) {
    121                         abort( "__cfaabi_interpose_startup : internal error, sigaltstack error(%d) %s.", errno, strerror( errno ) );
    122                 } // if
    123 
    124107                // Failure handler
    125                 __cfaabi_sigaction( SIGSEGV, sigHandler_segv, SA_SIGINFO | SA_ONSTACK );
    126                 __cfaabi_sigaction( SIGBUS , sigHandler_segv, SA_SIGINFO | SA_ONSTACK );
    127                 __cfaabi_sigaction( SIGILL , sigHandler_ill , SA_SIGINFO | SA_ONSTACK );
    128                 __cfaabi_sigaction( SIGFPE , sigHandler_fpe , SA_SIGINFO | SA_ONSTACK );
    129                 __cfaabi_sigaction( SIGTERM, sigHandler_term, SA_SIGINFO | SA_ONSTACK | SA_RESETHAND ); // one shot handler, return to default
    130                 __cfaabi_sigaction( SIGINT , sigHandler_term, SA_SIGINFO | SA_ONSTACK | SA_RESETHAND );
    131                 __cfaabi_sigaction( SIGABRT, sigHandler_term, SA_SIGINFO | SA_ONSTACK | SA_RESETHAND );
    132                 __cfaabi_sigaction( SIGHUP , sigHandler_term, SA_SIGINFO | SA_ONSTACK | SA_RESETHAND ); // terminal hangup
     108                __cfaabi_sigaction( SIGSEGV, sigHandler_segv , SA_SIGINFO );
     109                __cfaabi_sigaction( SIGBUS , sigHandler_segv , SA_SIGINFO );
     110                __cfaabi_sigaction( SIGILL , sigHandler_ill  , SA_SIGINFO );
     111                __cfaabi_sigaction( SIGFPE , sigHandler_fpe  , SA_SIGINFO );
     112                __cfaabi_sigaction( SIGABRT, sigHandler_abrt, SA_SIGINFO | SA_RESETHAND);
     113                __cfaabi_sigaction( SIGTERM, sigHandler_term , SA_SIGINFO );
     114                __cfaabi_sigaction( SIGINT , sigHandler_term , SA_SIGINFO );
    133115        }
    134116}
    … …  
    141123void exit( int status, const char fmt[], ... ) __attribute__(( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
    142124void abort( const char fmt[], ... ) __attribute__(( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
    143 void abort( bool signalAbort, const char fmt[], ... ) __attribute__(( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
    144125
    145126extern "C" {
    146127        void abort( void ) __attribute__(( __nothrow__, __leaf__, __noreturn__ )) {
    147                 abort( false, NULL ); // FIX ME: 0p does not work
     128                abort( NULL );
    148129        }
    149130
    … …  
    151132                va_list argp;
    152133                va_start( argp, fmt );
    153                 abort( false, fmt, argp );
     134                abort( fmt, argp );
    154135                va_end( argp );
    155136        }
    … …  
    160141}
    161142
    162 void * kernel_abort( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return 0p; }
    163 void kernel_abort_msg( void * data, char * buffer, int size ) __attribute__(( __nothrow__, __leaf__, __weak__ )) {}
    164 // See concurrency/kernel.cfa for strong definition used in multi-processor mode.
     143void * kernel_abort    ( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return NULL; }
     144void   kernel_abort_msg( void * data, char * buffer, int size ) __attribute__(( __nothrow__, __leaf__, __weak__ )) {}
    165145int kernel_abort_lastframe( void ) __attribute__(( __nothrow__, __leaf__, __weak__ )) { return 4; }
    166146
    167147enum { abort_text_size = 1024 };
    168148static char abort_text[ abort_text_size ];
    169 
    170 static void __cfaabi_backtrace( int start ) {
     149static int abort_lastframe;
     150
     151void exit( int status, const char fmt[], ... ) __attribute__(( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ )) {
     152    va_list args;
     153    va_start( args, fmt );
     154    vfprintf( stderr, fmt, args );
     155    va_end( args );
     156        __cabi_libc.exit( status );
     157}
     158
     159void abort( const char fmt[], ... ) __attribute__(( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )) {
     160        void * kernel_data = kernel_abort();                    // must be done here to lock down kernel
     161        int len;
     162
     163        abort_lastframe = kernel_abort_lastframe();
     164        len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld) ", (long int)getpid() ); // use UNIX pid (versus getPid)
     165        __cfaabi_dbg_write( abort_text, len );
     166
     167        if ( fmt ) {
     168                va_list args;
     169                va_start( args, fmt );
     170
     171                len = vsnprintf( abort_text, abort_text_size, fmt, args );
     172                va_end( args );
     173                __cfaabi_dbg_write( abort_text, len );
     174
     175                if ( fmt[strlen( fmt ) - 1] != '\n' ) {         // add optional newline if missing at the end of the format text
     176                        __cfaabi_dbg_write( "\n", 1 );
     177                }
     178        }
     179
     180        kernel_abort_msg( kernel_data, abort_text, abort_text_size );
     181        __cabi_libc.abort();
     182}
     183
     184static void __cfaabi_backtrace() {
    171185        enum {
    172186                Frames = 50,                                                                    // maximum number of stack frames
     187                Start = 8,                                                                              // skip first N stack frames
    173188        };
    174         int last = kernel_abort_lastframe();                            // skip last N stack frames
    175189
    176190        void * array[Frames];
    … …  
    178192        char ** messages = backtrace_symbols( array, size );
    179193
    180         *index( messages[0], '(' ) = '\0';                                      // find executable name
     194        // find executable name
     195        *index( messages[0], '(' ) = '\0';
    181196        __cfaabi_bits_print_nolock( STDERR_FILENO, "Stack back trace for: %s\n", messages[0]);
    182197
    183         for ( unsigned int i = start; i < size - last && messages != 0p; i += 1 ) {
     198        for ( int i = Start; i < size - abort_lastframe && messages != 0p; i += 1 ) {
    184199                char * name = 0p, * offset_begin = 0p, * offset_end = 0p;
    185200
    186                 for ( char * p = messages[i]; *p; ++p ) {               // find parantheses and +offset
     201                for ( char * p = messages[i]; *p; ++p ) {
    187202                        //__cfaabi_bits_print_nolock( "X %s\n", p);
     203                        // find parantheses and +offset
    188204                        if ( *p == '(' ) {
    189205                                name = p;
    … …  
    196212                }
    197213
    198                 // if line contains symbol, print it
    199                 int frameNo = i - start;
     214                // if line contains symbol print it
     215                int frameNo = i - Start;
    200216                if ( name && offset_begin && offset_end && name < offset_begin ) {
    201                         *name++ = '\0';                                                         // delimit strings
     217                        // delimit strings
     218                        *name++ = '\0';
    202219                        *offset_begin++ = '\0';
    203220                        *offset_end++ = '\0';
    … …  
    211228}
    212229
    213 void exit( int status, const char fmt[], ... ) {
    214         va_list args;
    215         va_start( args, fmt );
    216         vfprintf( stderr, fmt, args );
    217         va_end( args );
    218         __cabi_libc.exit( status );
    219 }
    220 
    221 void abort( bool signalAbort, const char fmt[], ... ) {
    222         void * kernel_data = kernel_abort();                            // must be done here to lock down kernel
    223         int len;
    224 
    225         signal( SIGABRT, SIG_DFL );                                                     // prevent final "real" abort from recursing to handler
    226 
    227         len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld) ", (long int)getpid() ); // use UNIX pid (versus getPid)
    228         __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
    229 
    230         if ( fmt ) {
    231                 va_list args;
    232                 va_start( args, fmt );
    233 
    234                 len = vsnprintf( abort_text, abort_text_size, fmt, args );
    235                 va_end( args );
    236                 __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
    237 
    238                 if ( fmt[strlen( fmt ) - 1] != '\n' ) {                 // add optional newline if missing at the end of the format text
    239                         __cfaabi_dbg_write( "\n", 1 );
    240                 }
    241         }
    242 
    243         kernel_abort_msg( kernel_data, abort_text, abort_text_size );
    244         __cfaabi_backtrace( signalAbort ? 4 : 3 );
    245 
    246         __cabi_libc.abort();                                                            // print stack trace in handler
    247 }
    248 
    249 void abort( const char fmt[], ... ) {
    250         va_list args;
    251         va_start( args, fmt );
    252         abort( false, fmt, args );
    253         va_end( args );
    254 }
    255 
    256230void sigHandler_segv( __CFA_SIGPARMS__ ) {
    257                 if ( sfp->si_addr == 0p ) {
    258                         abort( true, "Null pointer (0p) dereference.\n" );
     231                if ( sfp->si_addr == NULL ) {
     232                        abort( "Null pointer (0p) dereference.\n" );
    259233                } else {
    260                         abort( true, "%s at memory location %p.\n"
     234                        abort( "%s at memory location %p.\n"
    261235                                   "Possible cause is reading outside the address space or writing to a protected area within the address space with an invalid pointer or subscript.\n",
    262236                                   (sig == SIGSEGV ? "Segment fault" : "Bus error"), sfp->si_addr );
    … …  
    265239
    266240void sigHandler_ill( __CFA_SIGPARMS__ ) {
    267         abort( true, "Executing illegal instruction at location %p.\n"
     241        abort( "Executing illegal instruction at location %p.\n"
    268242                        "Possible cause is stack corruption.\n",
    269243                        sfp->si_addr );
    … …  
    281255          default: msg = "unknown";
    282256        } // choose
    283         abort( true, "Computation error %s at location %p.\n", msg, sfp->si_addr );
     257        abort( "Computation error %s at location %p.\n", msg, sfp->si_addr );
     258}
     259
     260void sigHandler_abrt( __CFA_SIGPARMS__ ) {
     261        __cfaabi_backtrace();
     262
     263        // reset default signal handler
     264        __cfaabi_sigdefault( SIGABRT );
     265
     266        raise( SIGABRT );
    284267}
    285268
    286269void sigHandler_term( __CFA_SIGPARMS__ ) {
    287         abort( true, "Application interrupted by signal: %s.\n", strsignal( sig ) );
     270        abort( "Application stopped by %s signal.", sig == SIGINT ? "an interrupt (SIGINT)" : "a terminate (SIGTERM)" );
    288271}
    289272
Note: See TracChangeset for help on using the changeset viewer.