stampa il motivo dell'errore di segmentazione

Question

Diciamo che ho un codice che causa un errore di segmentazione.

char * ptr = NULL; 
*ptr = "hello"; /* this will cause a segmentation fault */ 

Come esegue la stampa delle runtime, l'indirizzo in memoria che la colpa di segmentazione si è verificato a, e il motivo per il guasto di segmentazione (accedendo alla regione di memoria proibita, o altro).

Ho letto dei file di dump di base, ma non sono sicuro che sia la soluzione corretta.

Come posso fare questo?

P.S, sono a conoscenza del fatto che posso ottenerlo utilizzando gdb o un altro debugger, ma lo scopo è farlo utilizzando codice e solo codice.

Answer 1

Se si desidera conoscere la causa è possibile registrare un sig handler nale, qualcosa di simile:

void handler(int signum, siginfo_t *info, void *context) 
{ 
    struct sigaction action = { 
    .sa_handler = SIG_DFL, 
    .sa_sigaction = NULL, 
    .sa_mask = 0, 
    .sa_flags = 0, 
    .sa_restorer = NULL 
    }; 

    fprintf(stderr, "Fault address: %p\n", info->si_addr); 
    switch (info->si_code) { 
    case SEGV_MAPERR: 
    fprintf(stderr, "Address not mapped.\n"); 
    break; 

    case SEGV_ACCERR: 
    fprintf(stderr, "Access to this address is not allowed.\n"); 
    break; 

    default: 
    fprintf(stderr, "Unknown reason.\n"); 
    break; 
    } 

    /* unregister and let the default action occur */ 
    sigaction(SIGSEGV, &action, NULL); 
} 

E poi da qualche parte è necessario registrarlo:

struct sigaction action = { 
    .sa_handler = NULL, 
    .sa_sigaction = handler, 
    .sa_mask = 0, 
    .sa_flags = SA_SIGINFO, 
    .sa_restorer = NULL 
    }; 


    if (sigaction(SIGSEGV, &action, NULL) < 0) { 
    perror("sigaction"); 
    } 

In pratica si registra un segnale che viene generato quando SIGSEGV è consegnato, e si ottiene un po 'di informazioni aggiuntive, per citare la pagina man:

The following values can be placed in si_code for a SIGSEGV signal: 

     SEGV_MAPERR address not mapped to object 

     SEGV_ACCERR invalid permissions for mapped object 

Questi mappa per due motivi fondamentali f o ottenendo un errore di seg, o la pagina a cui si è eseguito l'accesso non è stata mappata affatto o non è stato consentito eseguire alcuna operazione che si è tentato di eseguire su quella pagina.

Qui, dopo che il gestore del segnale si è attivato, si annulla automaticamente e sostituisce l'azione predefinita. Ciò causa l'operazione che non è stata eseguita nuovamente in modo che possa essere catturata dal percorso normale. Questo è il comportamento normale di un errore di pagina (il precursore per ottenere un errore di seg) in modo che funzioni come il paging della domanda funzionino.

Answer 2

Come già risposto qui: How to generate a stacktrace when my gcc C++ app crashes

È possibile (nel caso di GCC con Linux/BSD almeno) fare questo abbastanza facile:

codice Esempio: uscita

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


void handler(int sig) { 
    void *array[10]; 
    size_t size; 

    // get void*'s for all entries on the stack 
    size = backtrace(array, 10); 

    // print out all the frames to stderr 
    fprintf(stderr, "Error: signal %d:\n", sig); 
    backtrace_symbols_fd(array, size, 2); 
    exit(1); 
} 

int main(int argc, char **argv) { 
    signal(SIGSEGV, handler); // install our handler 

    char * ptr = NULL; 
    *ptr = "hello"; /* this will cause a segmentation fault */ 
} 

Esempio :

# gcc -g -rdynamic -o test test.c 
# ./test 
Error: signal 11: 
0 test        0x000000010e99dcfa handler + 42 
1 libsystem_c.dylib     0x00007fff95c1194a _sigtramp + 26 
2 ???         0x0000000000000000 0x0 + 0 
3 libdyld.dylib      0x00007fff8fa177e1 start + 0 
4 ???         0x0000000000000001 0x0 + 1