on_exit和CTRL + C

Question

I've got a small program that opens a file and does some operation on it. I subscribed the file closure to the program termination as follows:

static
void exit_handler (int ev, void *arg)
{
    fprintf(stderr, "bye %d\n", WEXITSTATUS(ev));
    fclose((FILE *)arg);
}

int main (int argc, char *argv[])
{
    FILE *out;

    ...

    out = fopen(argv[1], "wt");
    if (out == NULL) {
        perror("Opening output file");
        exit(EXIT_FAILURE);
    }
    on_exit(exit_handler, out);

    ...
}

Trying to execute this I notice that it works properly only if the program terminates normally. In case of CTRL + C ( SIGINT ) the exit_handler callback is not executed.

Isn't that weird? Should I associate a exit(EXIT_FAILURE) call to the signal handler for SIGTERM ? What is the best practice in this case?

Answer 1

First of all, on_exit isn't specified by POSIX ( atexit with the same semantics is). Second , the linux manual says:

The on_exit() function registers the given function to be called at normal process termination , whether via exit(3) or via return from the program's main().

Getting killed by a signal is not a normal exit for a process so callbacks installed with on_exit and atexit aren't implicitly called.

Answer 2

on_exit will not be invoked for SIGTERM signals. You need to add a handler for it with signal . For example:

void signalHandler(void)
{
  ...
}

int main(void)
{
  signal(SIGTERM, signalHandler);
}

Also note that SIGKILL can not be caught by design.

Answer 3

No, and in fact what you want is impossible. The signal generated by Ctrl+C is asynchronous , meaning it could occur between any two machine instructions in your program depending on when Ctrl+C is hit. As such, unless your program is thoroughly avoiding calling async-signal-unsafe functions anywhere in the main program flow, it's illegal to call async-signal-unsafe functions from the signal handler. exit is async-signal-unsafe, as is most of the default cleanup activity it does (like flushing/closing open files). I would expect the atexit function you want to register ( atexit , not on_exit , is the correct name for this function) is also going to want to do async-signal-unsafe things.

If you need to perform cleanup when exiting based on a signal, you need to install a signal handler that does not exit itself, but instead sets a global volatile flag that your main program flow will later inspect (and exit if it's true).

Answer 4

From man page of on_exit ,

The on_exit() function registers the given function to be called at normal process termination, whether via exit(3) or via return from the program's main().

So you need to explicity hook up a handler for SIGTERM using specific functions from signal.h

Something on the lines of

struct sigaction action;

memset (&action, 0, sizeof(action));
action.sa_handler = sigterm_handler;

if (sigaction(SIGTERM, &action, 0)) 
{
    perror ("sigaction");
    return 1;
}

/* SIGTERM handler. */
static void sigterm_handler (int sig)
{
...
}