How to catch segmentation fault in Linux

Question

I need to catch segmentation fault in third party library cleanup operations  This happens sometimes just before my program exits  and I cannot fix the real reason of this  In Windows programming I could do this with   try -   catch  Is there cross-platform or platform-specific way to do the same  I need this in Linux  gcc

User · Accepted Answer

On Linux we can have these as exceptions, too.

Normally, when your program performs a segmentation fault, it is sent a SIGSEGV signal. You can set up your own handler for this signal and mitigate the consequences. Of course you should really be sure that you can recover from the situation. In your case, I think, you should debug your code instead.

Back to the topic. I recently encountered a library (short manual) that transforms such signals to exceptions, so you can write code like this:

try
{
    *(int*) 0 = 0;
}
catch (std::exception& e)
{
    std::cerr << "Exception caught : " << e.what() << std::endl;
}

~~Didn't check it, though.~~ Works on my x86-64 Gentoo box. It has a platform-specific backend (borrowed from gcc's java implementation), so it can work on many platforms. It just supports x86 and x86-64 out of the box, but you can get backends from libjava, which resides in gcc sources.

User · Answer

Sometimes we want to catch a SIGSEGV to find out if a pointer is valid  that is  if it references a valid memory address   Or even check if some arbitrary value may be a pointer    One option is to check it with isValidPtr    worked on Android    int isValidPtr const void p  int len        if   p        return 0            int ret   1      int nullfd   open   dev random   O WRONLY       if  write nullfd  p  len   lt  0        ret   0         Not OK              close nullfd       return ret    int isValidOrNullPtr const void p  int len        return  p  isValidPtr p  len       Another option is to read the memory protection attributes  which is a bit more tricky  worked on Android    re mprot c    include  lt errno h gt   include  lt malloc h gt     define PAGE SIZE 4096  include  dlog h   include  stdlib h   include  re mprot h   struct buffer       int pos      int size      char  mem      char   buf reset struct buffer b        b- gt mem b- gt pos    0      b- gt pos   0      return b- gt mem     struct buffer   new buffer int length        struct buffer  res   malloc sizeof struct buffer  length 4       res- gt pos   0      res- gt size   length      res- gt mem    void   res 1       return res     int  buf putchar struct buffer b  int c        b- gt mem b- gt pos      c      return b- gt pos  gt   b- gt size     void show mappings void        DLOG  ----------------------------------------------- n        int a      FILE  f   fopen   proc self maps    r        struct buffer  b    new buffer 1024       while   a   fgetc f    gt   0        if   buf putchar b a     a      n             DLOG   proc self maps   s   buf reset b                    if  b- gt pos        DLOG   proc self maps   s   buf reset b              free b       fclose f       DLOG  ----------------------------------------------- n       unsigned int read mprotection void  addr        int a      unsigned int res   MPROT 0      FILE  f   fopen   proc self maps    r        struct buffer  b    new buffer 1024       while   a   fgetc f    gt   0        if   buf putchar b a     a      n             char end0    void  0          unsigned long addr0   strtoul b- gt mem   amp end0  0x10           char end1    void  0          unsigned long addr1   strtoul end0 1   amp end1  0x10           if   void  addr0  lt  addr  amp  amp  addr  lt   void  addr1                res     end1 1  0      r    MPROT R   0              res     end1 1  1      w    MPROT W   0              res     end1 1  2      x    MPROT X   0              res     end1 1  3      p    MPROT P                     end1 1  3      s    MPROT S   0              break                     buf reset b                   free b       fclose f       return res     int has mprotection void  addr  unsigned int prot  unsigned int prot mask        unsigned prot1   read mprotection addr       return  prot1  amp  prot mask     prot     char   mprot tostring  char buf  unsigned int prot        buf 0    prot  amp  MPROT R    r     -       buf 1    prot  amp  MPROT W    w     -       buf 2    prot  amp  MPROT X    x     -       buf 3    prot  amp  MPROT S    s    prot  amp  MPROT P    p      -       buf 4    0      return buf      re mprot h    include  lt alloca h gt   include  re bits h   include  lt sys mman h gt   void show mappings void    enum       MPROT 0   0     not found at all     MPROT R   PROT READ                                     readable     MPROT W   PROT WRITE                                    writable     MPROT X   PROT EXEC                                     executable     MPROT S   FIRST UNUSED BIT MPROT R MPROT W MPROT X      shared     MPROT P   MPROT S lt  lt 1                                    private        returns a non-zero value if the address is mapped  because either MPROT P or MPROT S will be set for valid addresses  unsigned int read mprotection void  addr       check memory protection against the mask    returns true if all bits corresponding to non-zero bits in the mask    are the same in prot and read mprotection addr  int has mprotection void  addr  unsigned int prot  unsigned int prot mask       convert the protection mask into a string  Uses alloca    no need to free   the memory   define mprot tostring x     mprot tostring    char  alloca 8     x      char   mprot tostring  char buf  unsigned int prot     PS DLOG   is printf   to the Android log  FIRST UNUSED BIT   is defined here   PPS It may not be a good idea to call alloca   in a loop -- the memory may be not freed until the function returns

User · Answer

Here s an example of how to do it in C    include  lt signal h gt   include  lt stdio h gt   include  lt stdlib h gt   include  lt string h gt   void segfault sigaction int signal  siginfo t  si  void  arg        printf  Caught segfault at address  p n   si- gt si addr       exit 0      int main void        int  foo   NULL      struct sigaction sa       memset  amp sa  0  sizeof struct sigaction        sigemptyset  amp sa sa mask       sa sa sigaction   segfault sigaction      sa sa flags     SA SIGINFO       sigaction SIGSEGV   amp sa  NULL           Cause a seg fault         foo   1       return 0

User · Answer

For portability  one should probably use std  signal from the standard C   library  but there is a lot of restriction on what a signal handler can do  Unfortunately  it is not possible to catch a SIGSEGV from within a C   program without introducing undefined behavior because the specification says   it is undefined behavior to call any library function from within the handler other than a very narrow subset of the standard library functions  abort  exit  some atomic functions  reinstall current signal handler  memcpy  memmove  type traits   std  move  std  forward  and some more   it is undefined behavior if handler use a throw expression  it is undefined behavior if the handler returns when handling SIGFPE  SIGILL  SIGSEGV  This proves that it is impossible to catch SIGSEGV from within a program using strictly standard and portable C    SIGSEGV is still caught by the operating system and is normally reported to the parent process when a wait family function is called  You will probably run into the same kind of trouble using POSIX signal because there is a clause that says in 2 4 3 Signal Actions   The behavior of a process is undefined after it returns normally from a signal-catching function for a SIGBUS  SIGFPE  SIGILL  or SIGSEGV signal that was not generated by kill    sigqueue    or raise     A word about the longjumps  Assuming we are using POSIX signals  using longjump to simulate stack unwinding won t help   Although longjmp   is an async-signal-safe function  if it is invoked from a signal handler which interrupted a non-async-signal-safe function or equivalent  such as the processing equivalent to exit   performed after a return from the initial call to main     the behavior of any subsequent call to a non-async-signal-safe function or equivalent is undefined   This means that the continuation invoked by the call to longjump cannot reliably call usually useful library function such as printf  malloc or exit or return from main without inducing undefined behavior  As such  the continuation can only do a restricted operations and may only exit through some abnormal termination mechanism  To put things short  catching a SIGSEGV and resuming execution of the program in a portable is probably infeasible without introducing UB  Even if you are working on a Windows platform for which you have access to Structured exception handling  it is worth mentioning that MSDN suggest to never attempt to handle hardware exceptions  Hardware Exceptions  At last but not least  whether any SIGSEGV would be raised when dereferencing a null valued pointer  or invalid valued pointer  is not a requirement from the standard  Because indirection through a null valued pointer or any invalid  valued pointer is an undefined behaviour  which means the compiler assumes your code will never attempt such a thing at runtime  the compiler is free to make code transformation that would elide such undefined behavior  For example  from cppreference  int foo int  p        int x    p      if  p          return x     Either UB above or this branch is never taken     else         return 0      int main         int  p   nullptr      std  cout  lt  lt  foo p      Here the true path of the if could be completely elided by the compiler as an optimization  only the else part could be kept  Said otherwise  the compiler infers foo   will never receive a null valued pointer at runtime since it would lead to an undefined behaviour  Invoking it with a null valued pointer  you may observe the value 0 printed to standard output and no crash  you may observe a crash with SIGSEG   in fact you could observe anything since no sensible requirements are imposed on programs that are not free of undefined behaviors

User · Answer

C   solution found here  http   www cplusplus com forum unices 16430     include  lt signal h gt   include  lt stdio h gt   include  lt unistd h gt  void ouch int sig        printf  OUCH  - I got signal  d n   sig     int main         struct sigaction act      act sa handler   ouch      sigemptyset  amp act sa mask       act sa flags   0      sigaction SIGINT   amp act  0       while 1            printf  Hello World  n            sleep 1

[c++] How to catch segmentation fault in Linux?

Examples related to c++

Examples related to segmentation-fault

Examples related to try-catch