How To Create Core Dump

Core dump for Rust

Intro

From Wikipedia:

In computing, a core dump,[a] memory dump, crash dump, system dump, or ABEND dump[1] consists of the recorded state of the working memory of a computer program at a specific time, generally when the program has crashed or otherwise terminated abnormally.

In GNU/Linux core dump generation is handle by the kernel. And it can pipe the generation to a user-space program like systemd-coredump or apport. You can see if is handle by an external program looking into:

                              cat                /proc/sys/kernel/core_pattern |/usr/share/apport/apport %p %s %c

From core(5)

The default action of certain signals is to cause a process to
terminate and produce a core dump file, a file containing an
image of the process's memory at the time of termination. This
image can be used in a debugger (e.g., gdb(1)) to inspect the
state of the program at the time that it terminated. A list of
the signals which cause a process to dump core can be found in
signal(7).

Signals that generate a core dump.

SIGABRT Abort signal from abort(3)
SIGBUS Bus error (bad memory access)
SIGFPE Floating-point exception
SIGILL Illegal Instruction
SIGSEGV Invalid memory reference See the full documentation for a complete list.

Generate a core dump on Rust panics.

While rust panics itself help with the great information they provide. Sometimes it is really useful debug using a core dump specially if your binary has debug symbols plus the gdb wrappers provided by rust-gdb.

Instrument panic handler to generate coredump.

Most of fatal errors in Rust comes from a panic, unwraps that we considered safe (probably?).
Based in a really helpful gist I found:
https://gist.github.com/epilys/a6caba03cb02cfd2880fd80755cd08b8

First modify how the panic is handled by printing the panic trace as usual, but then send a signal that generates a core to our own process. In the example gist, the signal is SIGQUIT.

                              pub                fn                panic_handler_generate_coredump                ()                {                let                default_panic                =                std                ::                panic                ::                take_hook                ();                std                ::                panic                ::                set_hook                (                Box                ::                new                (                move                |                panic_info                |                {                default_panic                (                panic_info                );                let                pid                =                std                ::                process                ::                id                ();                use                libc                ::                kill                ;                use                libc                ::                SIGQUIT                ;                use                std                ::                convert                ::                TryInto                ;                unsafe                {                kill                (                pid                .try_into                ()                .unwrap                (),                SIGQUIT                )                };                }));                }                fn                main                (){                panic_handler_generate_coredump                ();                panic!                (                "don't Panic!"                )                }

Compile config

Optional:

                              [profile.dev]                opt-level                =                0                # Controls the --opt-level the compiler builds with                debug                =                true                # Controls whether the compiler passes `-g`

Enable core dump collection.

Optional: Change the path where coredump is generated

                              sudo                sysctl                -w                kernel.core_pattern=/tmp/core.%u.%p.%t

Or check where is generated:

              cat /proc/sys/kernel/core_pattern

Modify core file size:

From : https://community.perforce.com/s/article/2979

For most distributions the core file size limitation is set to 0 to produce no core files at all. To find out the limit on the system in question, issue the command:

              $ ulimit -c

If it is set to 0 then no core files are produced. To allow core files to be produced, set a core file size that is not 0:

              $ ulimit -c 100000000000

              $ ulimit -c unlimited

Generate core

              cargo run

Debug core

              rust-gdb <path-to-binary> /tmp/<core_path> thread apply all bt full #or where