记录Linux上使用C ++终止进程的原因

Question

Is there any way to log, handle or otherwise leave some clue about why a process terminates, covering as many termination-causing events as possible?

I have a logging tool for my application and log many messages every minute. I am running almost the whole program in a super try-catch block so I can log any unhandled exceptions. I have also recently tried registering handlers for various process signals that may terminate the process. However the application is still crashing a few times per day and I have no idea why.

How many other fatal events might I be failing to log or handle? I expect there is a proper way of doing this, rather than consistently being left in the dark when the process dies for some new type of event I am not yet aware of.

Thanks very much.

Answer 1

Having a super try/catch block means catchable exceptions aren't unhandled. Note that you'll need these blocks for all started threads.

That aside, you can use signal to catch termination signals. These are:

• SIGABRT (Signal Abort) Abnormal termination, such as is initiated by the abort function.
• SIGFPE (Signal Floating-Point Exception) Erroneous arithmetic operation, such as zero divide or an operation resulting in overflow (not necessarily with a floating-point operation).
• SIGILL (Signal Illegal Instruction) Invalid function image, such as an illegal instruction. This is generally due to a corruption in the code or to an attempt to execute data.
• SIGINT (Signal Interrupt) Interactive attention signal. Generally generated by the application user.
• SIGSEGV (Signal Segmentation Violation) Invalid access to storage: When a program tries to read or write outside the memory it is allocated for it. SIGTERM (Signal Terminate) Termination request sent to program.
• signals defined by the implementation, but most crash causes should be covered by these.

Also , it can be that the program is not crashing, but terminating either by returning from main (but I guess you already have that covered) or via a call to exit . In which case you can check the return value of the program and log that.

Answer 2

You can register a function to handle unexpected exceptions:

set_unexpected()

If not delt will with will cause application to call terminat().

You can register a function to log things on termination:

set_terminate()

You can add your own atexit() logging function that will do stuff (set a flag so that it only does stuff if exit happens abnormally then set the flag just before leaving main).

signal handler can be tricky (especially if you want them to be portable). If you use them you are limited in what you can do safely inside so I usually limit myself to setting a global flags so that they can be handled by normal code (of course if you are terminating then that is very limiting).

Answer 3

Here's what I use in my programs, it works for me.... whenever my program crashes it prints a stack trace of the crash site to stdout (which is presumably redirected to a file or etc where you can read it later).

Note that you may need to pass -rdynamic as a flag in CXXFLAGS and/or LFLAGS in your Makefile to make sure the stack trace contains human-readable function names.

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

void PrintStackTrace()
{
   void *array[256];
   size_t size = backtrace(array, 256);
   char ** strings = backtrace_symbols(array, 256);
   if (strings)
   {
      printf("--Stack trace follows (%zd frames):\n", size);
      for (size_t i = 0; i < size; i++) printf("  %s\n", strings[i]);
      printf("--End Stack trace\n");
      free(strings);
   }
   else printf("PrintStackTrace:  Error, could not generate stack trace!\n");
}

static void CrashSignalHandler(int sig)
{
   // Uninstall this handler, to avoid the possibility of an infinite regress
   signal(SIGSEGV, SIG_DFL);
   signal(SIGBUS,  SIG_DFL);
   signal(SIGILL,  SIG_DFL);
   signal(SIGABRT, SIG_DFL);
   signal(SIGFPE,  SIG_DFL);

   printf("CrashSignalHandler called with signal %i... I'm going to print a stack trace, then kill the process.\n", sig);
   PrintStackTrace();
   printf("Crashed process aborting now.... bye!\n");
   fflush(stdout);
   abort();
}

int main(int argc, char ** argv)
{
   signal(SIGSEGV, CrashSignalHandler);
   signal(SIGBUS,  CrashSignalHandler);
   signal(SIGILL,  CrashSignalHandler);
   signal(SIGABRT, CrashSignalHandler);
   signal(SIGFPE,  CrashSignalHandler);

   [...remainder of your program goes here...]
}

Answer 4

one code is worth many words:

#include <iostream>
#include <signal.h>

sigint_handler(int s) {
    std::cout<<"signal caught: "<<s<<std::endl;
    ::exit(-1);
}

void setup_signal() {
    struct sigaction sigIntHandler;
    sigIntHandler.sa_handler = sigint_handler;
    sigemptyset(&sigIntHandler.sa_mask);
    sigIntHandler.sa_flags = 0;
    sigaction(SIGINT, &sigIntHandler, NULL);
    sigaction(SIGTERM, &sigIntHandler, NULL);
}

int main() {
    setup_signal();
    /* do stuff */
    return 0;
}

of course, this only takes care of SIGINT/SIGTERM signals. You'll also have to update this code with all the atexit(), set_terminate, super try/catch etc.. you can find. And in case you run into segfaults/bus errors/whatever... well you're doomed :)

Answer 5

Check out this question. How to find the reason for a dead process without log file on unix?

There you will see that using bash to get the exit code of a process is much easier than using signal handlers or any kind of exit callbacks.