Я хотел бы принудительно создать дамп ядра в определенном месте в моем приложении C ++.

Я знаю, что могу сделать это, выполнив что-нибудь вроде:

int * crash = NULL;
*crash = 1;

Но хотелось бы знать, есть ли способ чище?

Кстати, я использую Linux.

Повышение сигнала номер 6 ( SIGABRTв Linux) - один из способов сделать это (хотя имейте в виду, что SIGABRT не обязательно должен быть 6 во всех реализациях POSIX, поэтому вы можете использовать само SIGABRTзначение, если это что-то другое, кроме quick'n 'грязный код отладки).

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

Вызов abort()также вызовет дамп ядра, и вы даже можете сделать это, не завершая свой процесс, путем вызова, fork()за которым следует только abort()дочерний элемент - см. Этот ответ для подробностей.

Несколько лет назад Google выпустила библиотеку coredumper .

Обзор

Библиотеку coredumper можно скомпилировать в приложения для создания дампов ядра запущенной программы - без завершения работы. Он поддерживает как однопоточные, так и многопоточные дампы ядра, даже если ядро ​​изначально не поддерживает многопоточные файлы ядра.

Coredumper распространяется на условиях лицензии BSD.

пример

Это далеко не полный пример; он просто дает вам представление о том, как выглядит API coredumper.

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

Это не то, о чем вы просили, но, может быть, даже лучше :)

Как указано на странице руководства по сигналам , любой сигнал с действием, указанным как 'core', вызовет дамп ядра. Вот несколько примеров:

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

Убедитесь, что вы включили дампы ядра:

ulimit -c unlimited

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

void core_dump(void)
{
    abort();
}

Вызвать

abort();

В связи с этим, иногда вам нужна обратная трассировка без фактического дампа ядра и позволить программе продолжить работу: ознакомьтесь с функциями glibc backtrace () и backtrace_symbols (): http://www.gnu.org/s/libc/ руководство / html_node / Backtraces.html

Другой способ создания дампа ядра:

$ bash
$ kill -s SIGSEGV $$

Просто создайте новый экземпляр bash и уничтожьте его указанным сигналом. Это $$PID оболочки. В противном случае вы убьете свой текущий bash и выйдете из системы, терминал будет закрыт или отключен.

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

Вы можете использовать kill (2) для отправки сигнала.

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

Так,

kill(getpid(), SIGSEGV);

Иногда бывает уместно сделать что-то вроде этого:

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

Одна проблема с этим простым подходом состоит в том, что только один поток будет объединен.

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

используйте этот подход везде, где хотите :)

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