Section 10.17. abort Function

10.17. abort Function

We mentioned earlier that the abort function causes abnormal program termination.

 #include <stdlib.h> void abort(void); 

This function never returns

This function sends the SIGABRT signal to the caller. (Processes should not ignore this signal.) ISO C states that calling abort will deliver an unsuccessful termination notification to the host environment by calling raise(SIGABRT).

ISO C requires that if the signal is caught and the signal handler returns, abort still doesn't return to its caller. If this signal is caught, the only way the signal handler can't return is if it calls exit, _exit, _Exit, longjmp, or siglongjmp. (Section 10.15 discusses the differences between longjmp and siglongjmp.) POSIX.1 also specifies that abort overrides the blocking or ignoring of the signal by the process.

The intent of letting the process catch the SIGABRT is to allow it to perform any cleanup that it wants to do before the process terminates. If the process doesn't terminate itself from this signal handler, POSIX.1 states that, when the signal handler returns, abort terminates the process.

The ISO C specification of this function leaves it up to the implementation as to whether output streams are flushed and whether temporary files (Section 5.13) are deleted. POSIX.1 goes further and requires that if the call to abort terminates the process, then the effect on the open standard I/O streams in the process will be the same as if the process had called fclose on each stream before terminating.

Earlier versions of System V generated the SIGIOT signal from the abort function. Furthermore, it was possible for a process to ignore this signal or to catch it and return from the signal handler, in which case abort returned to its caller.

4.3BSD generated the SIGILL signal. Before doing this, the 4.3BSD function unblocked the signal and reset its disposition to SIG_DFL (terminate with core file). This prevented a process from either ignoring the signal or catching it.

Historically, implementations of abort differ in how they deal with standard I/O streams. For defensive programming and improved portability, if we want standard I/O streams to be flushed, we specifically do it before calling abort. We do this in the err_dump function (Appendix B).

Since most UNIX System implementations of tmpfile call unlink immediately after creating the file, the ISO C warning about temporary files does not usually concern us.

Example

Figure 10.25 shows an implementation of the abort function as specified by POSIX.1.

We first see whether the default action will occur; if so, we flush all the standard I/O streams. This is not equivalent to an fclose on all the open streams (since it just flushes them and doesn't close them), but when the process terminates, the system closes all open files. If the process catches the signal and returns, we flush all the streams again, since the process could have generated more output. The only condition we don't handle is if the process catches the signal and calls _exit or _Exit. In this case, any unflushed standard I/O buffers in memory are discarded. We assume that a caller that does this doesn't want the buffers flushed.

Recall from Section 10.9 that if calling kill causes the signal to be generated for the caller, and if the signal is not blocked (which we guarantee in Figure 10.25), then the signal (or some other pending, unlocked signal) is delivered to the process before kill returns. We block all signals except SIGABRT, so we know that if the call to kill returns, the process caught the signal and the signal handler returned.

Figure 10.25. Implementation of POSIX.1 abort

 #include <signal.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> void abort(void)         /* POSIX-style abort() function */ {     sigset_t           mask;     struct sigaction   action;     /*      * Caller can't ignore SIGABRT, if so reset to default.      */     sigaction(SIGABRT, NULL, &action);     if (action.sa_handler == SIG_IGN) {         action.sa_handler = SIG_DFL;         sigaction(SIGABRT, &action, NULL);     }     if (action.sa_handler == SIG_DFL)         fflush(NULL);           /* flush all open stdio streams */     /*      * Caller can't block SIGABRT; make sure it's unblocked.      */     sigfillset(&mask);     sigdelset(&mask, SIGABRT);  /* mask has only SIGABRT turned off */     sigprocmask(SIG_SETMASK, &mask, NULL);     kill(getpid(), SIGABRT);    /* send the signal */     /*      * If we're here, process caught SIGABRT and returned.      */     fflush(NULL);               /* flush all open stdio streams */     action.sa_handler = SIG_DFL;     sigaction(SIGABRT, &action, NULL);  /* reset to default */     sigprocmask(SIG_SETMASK, &mask, NULL);  /* just in case ... */     kill(getpid(), SIGABRT);                /* and one more time */     exit(1);    /* this should never be executed ... */ }