Insumos para la mejora de código debuggability aparte de los registros y los códigos de error

Question

Además de los códigos de error, cadenas de error y los registros, ¿existen otras características que pueden ser incorporados en el código para aumentar la obtención de información de depuración / trace en tiempo de ejecución de código que puede ayudar a depurar problemas (o hacernos saber lo que está pasando) en tiempo de ejecución?

Answer 1

Este es un ejemplo del código que envía una StackTrace a un archivo en un fallo de segmentación

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

static void signal_handler(int);
static void dumpstack(void);
static void cleanup(void);
void init_signals(void);
void panic(const char *, ...);

struct sigaction sigact;
char *progname;

int main(int argc, char **argv){
    char *s;
    progname = *(argv);
    atexit(cleanup);
    init_signals();
    printf("About to seg fault by assigning zero to *s\n");
    *s = 0;
    sigemptyset(&sigact.sa_mask);
    return 0;
}

void init_signals(void){
    sigact.sa_handler = signal_handler;
    sigemptyset(&sigact.sa_mask);
    sigact.sa_flags = 0;
    sigaction(SIGINT, &sigact, (struct sigaction *)NULL);

    sigaddset(&sigact.sa_mask, SIGSEGV);
    sigaction(SIGSEGV, &sigact, (struct sigaction *)NULL);

    sigaddset(&sigact.sa_mask, SIGBUS);
    sigaction(SIGBUS, &sigact, (struct sigaction *)NULL);

    sigaddset(&sigact.sa_mask, SIGQUIT);
    sigaction(SIGQUIT, &sigact, (struct sigaction *)NULL);

    sigaddset(&sigact.sa_mask, SIGHUP);
    sigaction(SIGHUP, &sigact, (struct sigaction *)NULL);

    sigaddset(&sigact.sa_mask, SIGKILL);
    sigaction(SIGKILL, &sigact, (struct sigaction *)NULL);
}

static void signal_handler(int sig){
    if (sig == SIGHUP) panic("FATAL: Program hanged up\n");
    if (sig == SIGSEGV || sig == SIGBUS){
        dumpstack();
        panic("FATAL: %s Fault. Logged StackTrace\n", (sig == SIGSEGV) ? "Segmentation" : ((sig == SIGBUS) ? "Bus" : "Unknown"));
    }
    if (sig == SIGQUIT) panic("QUIT signal ended program\n");
    if (sig == SIGKILL) panic("KILL signal ended program\n");
    if (sig == SIGINT) ;
}

void panic(const char *fmt, ...){
    char buf[50];
    va_list argptr;
    va_start(argptr, fmt);
    vsprintf(buf, fmt, argptr);
    va_end(argptr);
    fprintf(stderr, buf);
    exit(-1);
}

static void dumpstack(void){
    /* Got this routine from http://www.whitefang.com/unix/faq_toc.html
    ** Section 6.5. Modified to redirect to file to prevent clutter
    */
    char dbx[160];
    sprintf(dbx, "echo 'where\ndetach' | dbx -a %d > %s.dump", getpid(), progname);
    system(dbx);
    return;
}

void cleanup(void){
    sigemptyset(&sigact.sa_mask);
    /* Do any cleaning up chores here */
}

En el dumpstack función, dbx necesita ser cambiado para adaptarse a su depurador, como gdb para el depurador GNU, este código se utiliza cuando estaba programando en AIX caja hace unos años. Observe cómo las señales están configurados, y si se produce un fallo SIGSEGV, el manejador vuelca la pila en un archivo con extensión .dump. El código se muestra el fallo de segmentación y vuelca el StackTrace.

Esto es mi código favorito.

Espero que esta ayuda, Atentamente, Tom.

Answer 2

• Construir sin optimización, para preservar la mayor cantidad de "intención" del código como sea posible
• Construir en modo de depuración, para agregar información de símbolos
• No quita el ejecutable (en sistemas Linux / Unix), para mantener la mayor cantidad de información posible símbolo de depuradores de uso

Answer 3

Cuando se construye para Linux, me gustaría ser capaz de imprimir un pila traza de un manejador de señales. Esto ayuda a los accidentes de depuración (SIGSEGV) o me permite enviar una señal al programa para iniciar una traza de pila en tiempo de ejecución. Core vertederos también pueden ser útiles en la depuración de accidentes (de nuevo en Linux).