一天一个C Run-Time Library 函数（3） abort

void
abort( void );

#include <stdlib.h>
#include <stdio.h>

int main()
{
    
    printf("Running/n");
    
    abort();
    
    printf("Still Running/n");
    return 0;
}

void
(__cdecl *signal(   int _sig_ ,    void (__cdecl *_func_ ) (int [, int ] )))   (int);

#include <stdlib.h>
#include <stdio.h>
#include <signal.h>

void Abort(int ai)
{
    printf("catch the SIGABRT and agrument is %d", ai);
}

int main()
{
    
    printf("Running/n");
    
    signal(SIGABRT, Abort);
    
    abort();
    
    printf("Still Running/n");
    return 0;
}

#define SIGABRT_COMPAT  6       
/* SIGABRT compatible with other platforms,  
same as SIGABRT */

void __cdecl abort (
        void
        )
{
    _PHNDLR sigabrt_act = SIG_DFL;

    if (__abort_behavior & _WRITE_ABORT_MSG)
    {
        /* write the  
abort message */
        _NMSG_WRITE(_RT_ABORT);
    }

................

    /* Check if the  
user installed a handler for SIGABRT.

     * We need to read the user handler  
atomically in the case

     * another thread is aborting while we  
change the signal

     * handler.

     */
    sigabrt_act  
= __get_sigabrt();
    if (sigabrt_act != SIG_DFL)
    {
        raise(SIGABRT);
    }
    _exit(3);
}

/* We must  
avoid to run in circles.  Therefore we  
remember how far we
already  
got.  */
static int stage;

/* We  
should be prepared for multiple threads trying to run abort.  */
__libc_lock_define_initialized_recursive (static,  
lock);



/* Cause an abnormal program  
termination with core-dump.  */
void abort (void)
{
    struct sigaction  
act;
    sigset_t sigs;

    /* First acquire the lock.  */
    __libc_lock_lock_recursive (lock);

    /* Now it's for sure we are alone.  But recursive calls are possible.  */

    /* Unlock SIGABRT.  */
    if (stage  
== 0)
    {
       ++stage;
       if (__sigemptyset  
(&sigs) == 0 &&
           __sigaddset (&sigs, SIGABRT)  
== 0)
           __sigprocmask (SIG_UNBLOCK, &sigs,  
(sigset_t *) NULL);
    }

    /* Flush all streams.  We cannot close them now because the user
    might have registered a handler for  
SIGABRT.  */
    if (stage  
== 1)
    {
       ++stage;
       fflush (NULL);
    }

    /* Send signal which possibly calls a  
user handler.  */
    if (stage  
== 2)
    {

        /*  
This stage is special: we must allow repeated calls of

       `abort' when a user defined handler for  
SIGABRT is installed.

       This is risky since the `raise'  
implementation might also

       fail but I don't see another  
possibility.  */
       int save_stage  
= stage;

       stage = 0;
       __libc_lock_unlock_recursive  
(lock);

       raise (SIGABRT);

       __libc_lock_lock_recursive  
(lock);
       stage = save_stage + 1;
    }

    /* There was a handler installed.  Now remove it.  */
    if (stage  
== 3)
    {
       ++stage;
       memset (&act, '/0', sizeof (struct sigaction));
       act.sa_handler = SIG_DFL;
       __sigfillset (&act.sa_mask);
       act.sa_flags = 0;
       __sigaction (SIGABRT, &act,  
NULL);
    }

    /* Now close the streams which also  
flushes the output the user
    defined handler might has produced.  */
    if (stage  
== 4)
    {
       ++stage;
       __fcloseall ();
    }

    /* Try again.  */
    if (stage  
== 5)
    {
       ++stage;
       raise (SIGABRT);
    }

    /* Now try to abort using the system  
specific command.  */
    if (stage  
== 6)
    {
       ++stage;
       ABORT_INSTRUCTION;
    }

    /* If we can't signal ourselves and the  
abort instruction failed, exit.  */
    if (stage  
== 7)
    {
       ++stage;
       _exit(127);
    }

    /* If even this fails try to use the  
provided instruction to crash
    or otherwise make sure we never return.  */
    while (1)
       /* Try for ever and ever.  */
       ABORT_INSTRUCTION;
}