Cómo generar un volcado de núcleo de Linux en un fallo de segmentación?

Question

Tengo un proceso en Linux consiguiendo un fallo de segmentación.¿Cómo puedo saber a la hora de generar un volcado de núcleo cuando se produce un error?

Answer 1

Esto depende de lo que shell está utilizando.Si usted está usando bash, a continuación, el comando ulimit controla varios parámetros relativos a la ejecución del programa, tales como si debe de volcado de núcleo.Si el tipo de

ulimit -c unlimited

entonces que va a decirle a bash que sus programas pueden volcar los núcleos de cualquier tamaño.Puede especificar un tamaño como 52M en lugar de un número ilimitado si quieres, pero en la práctica esto no debería ser necesario, ya que el tamaño de los archivos principales probablemente nunca será un problema para usted.

En tcsh, debes escribir

limit coredumpsize unlimited

Answer 2

Como se explicó anteriormente la verdadera pregunta aquí es cómo habilitar volcados en un sistema donde no están habilitadas.Esa pregunta está respondida aquí.

Si usted ha venido aquí con la esperanza de aprender a generar un volcado de núcleo para un proceso bloqueado, la respuesta es

gcore <pid>

si gcore no está disponible en su sistema, entonces

kill -ABRT <pid>

No utilizar kill -SEGV como que se suelen invocar un manejador de señal lo que es más difícil de diagnosticar el proceso de pegado

Answer 3

Lo que hice al final fue adjuntar gdb para el proceso antes de que se estrelló, y que cuando se hizo la violación de segmento he ejecutado el generate-core-file comando.Que obligó a la generación de un volcado de núcleo.

Answer 4

Para comprobar que los volcados de núcleo se generan, ejecute:

sysctl kernel.core_pattern

o:

cat /proc/sys/kernel/core_pattern

donde %e es el nombre del proceso y %t la hora del sistema.Usted puede cambiar en /etc/sysctl.conf y la recarga por sysctl -p.

Si los archivos del núcleo no se generan (prueba: sleep 10 & y killall -SIGSEGV sleep), verificación de los límites por: ulimit -a.

Si el núcleo de su tamaño del archivo es limitado, ejecute:

ulimit -c unlimited

para hacer que sea ilimitado.

Luego prueba de nuevo, si el núcleo de dumping es correcta, aparecerá "(colapsaba)" después de la segmentación de indicación de fallo de la siguiente manera:

Un fallo de segmentación:11 (colapsaba)

Vea también: colapsaba - pero el núcleo de archivo no está en el directorio actual?

---

Ubuntu

En Ubuntu la volcados de núcleo son manejados por Apport y puede ser ubicado en /var/crash/.Sin embargo, se está desactivado por defecto en versiones estables.

Para obtener más detalles, consulte: Donde puedo encontrar el volcado de núcleo en Ubuntu?.

macOS

Para macOS, consulte: Cómo generar volcados de núcleo en Mac OS X?

Answer 5

Tal vez podría hacerlo de esta manera, este programa es una demostración de cómo atrapar a un fallo de segmentación y conchas a un depurador (este es el código original utilizado bajo AIX) e imprime el seguimiento de la pila hasta el punto de que un fallo de segmentación.Usted tendrá que cambiar la sprintf la variable que se usará gdb en el caso de Linux.

#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
    */
    /* This needs to be changed... */
    char dbx[160];

    sprintf(dbx, "echo 'where\ndetach' | dbx -a %d > %s.dump", getpid(), progname);
    /* Change the dbx to gdb */

    system(dbx);
    return;
}

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

Puede que tenga que agregar un parámetro para obtener gdb para el volcado de núcleo como se muestra aquí en este blog aquí.

Answer 6

Hay más cosas que puede influir en la generación de un volcado de núcleo.He encontrado estos:

• el directorio de la descarga debe tener permisos de escritura.Por defecto es el directorio actual del proceso, pero que puede ser cambiado mediante el establecimiento de /proc/sys/kernel/core_pattern.
• en algunas condiciones, el núcleo de valor en /proc/sys/fs/suid_dumpable puede evitar que el núcleo se genera.

Hay más situaciones que pueden impedir la generación que se describen en la página man de - intentar man core.

Answer 7

Con el fin de activar el core dump hacer lo siguiente:

1. En /etc/profile comentario de la línea:

   # ulimit -S -c 0 > /dev/null 2>&1
   

2. En /etc/security/limits.conf la línea de comentario:

   *               soft    core            0
   

3. ejecutar el cmd limit coredumpsize unlimited y comprobar con cmd limit:

   # limit coredumpsize unlimited
   # limit
   cputime      unlimited
   filesize     unlimited
   datasize     unlimited
   stacksize    10240 kbytes
   coredumpsize unlimited
   memoryuse    unlimited
   vmemoryuse   unlimited
   descriptors  1024
   memorylocked 32 kbytes
   maxproc      528383
   #
   

4. para comprobar si la corefile se escribe se puede matar a la relación del proceso con cmd kill -s SEGV <PID> (en caso de no ser necesaria, sólo en caso de que ningún archivo central se escriben esto puede ser utilizado como un cheque):

   # kill -s SEGV <PID>
   

Una vez que el corefile ha sido escrito asegúrese de desactivar la coredump ajustes de nuevo en la relación de los archivos (1./2./3.) !

Answer 8

Para Ubuntu 14.04

1. Verificación de volcado de núcleo habilitado:

   ulimit -a
   

2. Una de las líneas debe ser :

   core file size          (blocks, -c) unlimited
   

3. Si no :

   gedit ~/.bashrc y agregar ulimit -c unlimited al final del archivo y guardar, volver a ejecutar el terminal.

4. Crear una aplicación con información de depuración :

   En El Fichero Makefile -O0 -g

5. Ejecutar la aplicación que crear core dump (volcado de núcleo archivo con el nombre de 'core' debe ser creado cerca de nombreaplicación archivo):

   ./application_name
   

6. Ejecutar bajo gdb:

   gdb application_name core
   

Answer 9

Por defecto, obtendrá un archivo de núcleo.Compruebe que el directorio actual del proceso de escritura, o sin núcleo archivo será creado.

Answer 10

Mejor para encender volcado de núcleo mediante programación utilizando la llamada al sistema setrlimit.

ejemplo:

#include <sys/resource.h>

bool enable_core_dump(){    
    struct rlimit corelim;

    corelim.rlim_cur = RLIM_INFINITY;
    corelim.rlim_max = RLIM_INFINITY;

    return (0 == setrlimit(RLIMIT_CORE, &corelim));
}

Answer 11

Esperar.Hace automáticamente.No hay necesidad de hacerlo

Answer 12

Vale la pena mencionar que si usted tiene un systemd establecer, entonces las cosas son un poco diferentes.La puesta en marcha normalmente tendría los archivos del núcleo se canaliza, por medio de core_pattern sysctl valor, a través de systemd-coredump(8).El núcleo de tamaño de archivo rlimit suele ser configurado como "ilimitado" ya.

Es posible recuperar los volcados de núcleo mediante coredumpctl(1).

El almacenamiento de los volcados de núcleo, etc.está configurado por coredump.conf(5).Hay ejemplos de cómo obtener los archivos del núcleo en el coredumpctl hombre de la página, pero en fin, tendría este aspecto:

Encuentra el núcleo de archivo:

[vps@phoenix]~$ coredumpctl list test_me | tail -1
Sun 2019-01-20 11:17:33 CET   16163  1224  1224  11 present /home/vps/test_me

Obtener el archivo de núcleo:

[vps@phoenix]~$ coredumpctl -o test_me.core dump 16163