CODEWITHSUNDEEP
c++clinuxcoredumpabort
hhafez
hhafez

Reputation: 39750

How to programmatically cause a core dump in C/C++

I would like to force a core dump at a specific location in my C++ application.

I know I can do it by doing something like:

int * crash = NULL;
*crash = 1;

But I would like to know if there is a cleaner way?

I am using Linux by the way.

Upvotes: 106

Views: 103038

Answers (10)

rka444
rka444

Reputation: 31

Sometimes it may be appropriate to do something like this:

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

One problem with this simple approach is that only one thread will be coredumped.

Upvotes: 3

smcameron
smcameron

Reputation: 2557

Invoke

abort();

Related, sometimes you'd like a back trace without an actual core dump, and allow the program to continue running: check out glibc backtrace() and backtrace_symbols() functions: http://www.gnu.org/s/libc/manual/html_node/Backtraces.html

Upvotes: 13

S.P
S.P

Reputation: 8756

As listed in the signal manpage, any signal with the action listed as 'core' will force a core dump. Some examples are:

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

Make sure that you enable core dumps:

ulimit -c unlimited

Upvotes: 41

paxdiablo
paxdiablo

Reputation: 881103

Raising of signal number 6 (SIGABRT in Linux) is one way to do it (though keep in mind that SIGABRT is not required to be 6 in all POSIX implementations so you may want to use the SIGABRT value itself if this is anything other than quick'n'dirty debug code).

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

Calling abort() will also cause a core dump, and you can even do this without terminating your process by calling fork() followed by abort() in the child only - see this answer for details.

Upvotes: 91

karthik339
karthik339

Reputation: 309

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

use this approach wherever you want :)

Upvotes: 1

Zonk
Zonk

Reputation: 171

Another way of generating a core dump:

$ bash
$ kill -s SIGSEGV $$

Just create a new instance of the bash and kill it with specified signal. The $$ is the PID of the shell. Otherwise you are killing your current bash and will be logged out, terminal closed or disconnected.

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

Upvotes: 7

sigjuice
sigjuice

Reputation: 29749

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

Upvotes: 0

Eugene Yokota
Eugene Yokota

Reputation: 95604

You can use kill(2) to send signal.

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

So,

kill(getpid(), SIGSEGV);

Upvotes: 4

ephemient
ephemient

Reputation: 204668

A few years ago, Google released the coredumper library.

Overview

The coredumper library can be compiled into applications to create core dumps of the running program -- without terminating. It supports both single- and multi-threaded core dumps, even if the kernel does not natively support multi-threaded core files.

Coredumper is distributed under the terms of the BSD License.

Example

This is by no means a complete example; it simply gives you a feel for what the coredumper API looks like.

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

It's not what you were asking for, but maybe it's even better :)

Upvotes: 79

Jonathan Leffler
Jonathan Leffler

Reputation: 753475

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

void core_dump(void)
{
    abort();
}

Upvotes: 35

Related Questions