coredump: add %i/%I in core_pattern to report the tid of the crashed thread
authorOleg Nesterov <>
Mon, 13 Oct 2014 22:53:35 +0000 (15:53 -0700)
committerLinus Torvalds <>
Tue, 14 Oct 2014 00:18:21 +0000 (02:18 +0200)
format_corename() can only pass the leader's pid to the core handler,
but there is no simple way to figure out which thread originated the

As Jan explains, this also means that there is no simple way to create
the backtrace of the crashed process:

As programs are mostly compiled with implicit gcc -fomit-frame-pointer
one needs program's .eh_frame section (equivalently PT_GNU_EH_FRAME
segment) or .debug_frame section.  .debug_frame usually is present only
in separate debug info files usually not even installed on the system.
While .eh_frame is a part of the executable/library (and it is even
always mapped for C++ exceptions unwinding) it no longer has to be
present anywhere on the disk as the program could be upgraded in the
meantime and the running instance has its executable file already
unlinked from disk.

One possibility is to echo 0x3f >/proc/*/coredump_filter and dump all
the file-backed memory including the executable's .eh_frame section.
But that can create huge core files, for example even due to mmapped
data files.

Other possibility would be to read .eh_frame from /proc/PID/mem at the
core_pattern handler time of the core dump.  For the backtrace one needs
to read the register state first which can be done from core_pattern

    close(0);    // close pipe fd to resume the sleeping dumper
    waitpid();   // should report EXIT
    PTRACE_GETREGS or other requests

The remaining problem is how to get the 'tid' value of the crashed
thread.  It could be read from the first NT_PRSTATUS note of the core
file but that makes the core_pattern handler complicated.

Unfortunately %t is already used so this patch uses %i/%I.

Automatic Bug Reporting Tool (
is experimenting with this.  It is using the elfutils
( unwinder for generating the
backtraces.  Apart from not needing matching executables as mentioned
above, another advantage is that we can get the backtrace without saving
the core (which might be quite large) to disk.

[ final paragraph of changelog]
Signed-off-by: Jan Kratochvil <>
Signed-off-by: Oleg Nesterov <>
Cc: Alexander Viro <>
Cc: Denys Vlasenko <>
Cc: Jan Kratochvil <>
Cc: Mark Wielaard <>
Cc: Martin Milata <>
Signed-off-by: Andrew Morton <>
Signed-off-by: Linus Torvalds <>

index f79eb96663790f1c116f6a44d706af048bdedc88..57baff5bdb806b3b725bdc7859c385fbdc1cac54 100644 (file)
@@ -190,6 +190,8 @@ core_pattern is used to specify a core dumpfile pattern name.
        %%      output one '%'
        %p      pid
        %P      global pid (init PID namespace)
+       %i      tid
+       %I      global tid (init PID namespace)
        %u      uid
        %g      gid
        %d      dump mode, matches PR_SET_DUMPABLE and
index a93f7e6ea4cf935aea64e8266b221a2c53477628..b5c86ffd5033420523934c7153080d8cdc605bea 100644 (file)
@@ -199,6 +199,14 @@ static int format_corename(struct core_name *cn, struct coredump_params *cprm)
                                err = cn_printf(cn, "%d",
+                       case 'i':
+                               err = cn_printf(cn, "%d",
+                                             task_pid_vnr(current));
+                               break;
+                       case 'I':
+                               err = cn_printf(cn, "%d",
+                                             task_pid_nr(current));
+                               break;
                        /* uid */
                        case 'u':
                                err = cn_printf(cn, "%d", cred->uid);