Me gustaría forzar un volcado de memoria en una ubicación específica en mi aplicación C ++.

Sé que puedo hacerlo haciendo algo como:

int * crash = NULL;
*crash = 1;

Pero me gustaría saber si hay una forma más limpia.

Estoy usando Linux por cierto.

El aumento de la señal número 6 ( SIGABRTen Linux) es una forma de hacerlo (aunque tenga en cuenta que no se requiere que SIGABRT sea ​​6 en todas las implementaciones POSIX, por lo que es posible que desee usar el SIGABRTvalor en sí mismo si esto es algo diferente a quick'n 'código de depuración sucio).

#include <signal.h>
: : :
raise (SIGABRT);

Llamar abort()también causará un volcado del núcleo, e incluso puede hacer esto sin terminar su proceso llamando fork()seguido de solo abort()en el niño; consulte esta respuesta para obtener más detalles.

Hace unos años, Google lanzó la biblioteca coredumper .

Visión general

La biblioteca coredumper se puede compilar en aplicaciones para crear volcados del núcleo del programa en ejecución, sin terminar. Admite volcados de núcleo de subproceso único y múltiple, incluso si el kernel no admite de forma nativa archivos de núcleo de subproceso múltiple.

Coredumper se distribuye según los términos de la licencia BSD.

Ejemplo

Este no es de ninguna manera un ejemplo completo; simplemente le da una idea de cómo se ve la API de coredumper.

#include <google/coredumper.h>
...
WriteCoreDump('core.myprogram');
/* Keep going, we generated a core file,
 * but we didn't crash.
 */

No es lo que estabas pidiendo, pero tal vez sea incluso mejor :)

Como se enumera en la página de manual de la señal , cualquier señal con la acción listada como 'núcleo' forzará un volcado de núcleo. Algunos ejemplos son:

SIGQUIT       3       Core    Quit from keyboard
SIGILL        4       Core    Illegal Instruction
SIGABRT       6       Core    Abort signal from abort(3)
SIGFPE        8       Core    Floating point exception
SIGSEGV      11       Core    Invalid memory reference

Asegúrese de habilitar los volcados de memoria:

ulimit -c unlimited

#include <stdlib.h>   // C
//#include <cstdlib>  // C++

void core_dump(void)
{
    abort();
}

Invocar

abort();

Relacionado, a veces le gustaría un seguimiento sin un volcado de núcleo real y permitir que el programa continúe ejecutándose: consulte las funciones glibc backtrace () y backtrace_symbols (): http://www.gnu.org/s/libc/ manual / html_node / Backtraces.html

Otra forma de generar un volcado de memoria:

$ bash
$ kill -s SIGSEGV $$

Simplemente cree una nueva instancia de bash y elimínela con la señal especificada. El $$es el PID del shell. De lo contrario, está eliminando su bash actual y se cerrará la sesión, se cerrará o desconectará la terminal.

$ bash 
$ kill -s SIGABRT $$
$ bash
$ kill -s SIGFPE $$

Puedes usar kill (2) para enviar la señal.

#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);

Entonces,

kill(getpid(), SIGSEGV);

A veces, puede ser apropiado hacer algo como esto:

int st = 0;
pid_t p = fork();

if (!p) {
    signal(SIGABRT, SIG_DFL);
    abort(); // having the coredump of the exact copy of the calling thread
} else {
    waitpid(p, &st, 0); // rip the zombie
}

// here the original process continues to live

Un problema con este enfoque simple es que solo se realizará el coredumped en un hilo.

 #include <stdio.h>
 #include <stdlib.h>
 int main()
 {
   printf("\n");
   printf("Process is aborting\n");
   abort();
   printf("Control not reaching here\n");
   return 0;
 }

usa este enfoque donde quieras :)

#include <assert.h>
.
.
.
     assert(!"this should not happen");