Thread-spezifische Daten von linux core dump

Soweit ich weiß, gibt es keinen Befehl in der gdb um einen Zeiger auf den gespeicherten Daten über pthread_setspecific(). Allerdings gibt es ein paar Optionen zu erhalten, wird die Speicher-Adresse:

• Prüfen jeden thread backtrace, überprüfen Sie jeden frame, um zu sehen, wenn das Ergebnis der pthread_getspecific() immer noch auf dem Stapel.
• Ändern bestehenden code zu Protokoll beide thread-id und das Ergebnis pthread_getspecific().
• Suchen Sie die thread-spezifische Daten Liste innerhalb des threads internen Daten, dann verwenden Sie die Taste, um den gewünschten Eintrag gefunden wird, enthalten die Adresse. Dieser Ansatz ist abhängig von der pthread-Bibliothek Implementierung; so, es erfordert entweder die Kenntnis der pthread-Implementierung verwendet werden, oder reverse engineering mit ein wenig Geduld.

Unten ist ein Demo mit einem einfachen Programm auf einem 32-bit-Maschine:

• g++ (GCC) 4.1.2 20080704 (Red Hat 4.1.2-48)
• libpthread-2.5.so
• GNU gdb Red Hat Linux (6.5-25.el5rh)

---

$cat example.cpp
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

void* the_thread( void* ); 
void get_position();

struct position_t
{
  int x;
  int y;
};

namespace {
  pthread_key_t position_key;

  enum {
    NUMBER_OF_THREADS = 2
  };
} //unnamed

int main(int argc, char **argv)
{
  int result = pthread_key_create( &position_key, NULL );
  printf( "pthread_key_create -- key: %u, result: %i\n",
          position_key, result );

  pthread_t threads[NUMBER_OF_THREADS];
  for (unsigned int i = 0; i < NUMBER_OF_THREADS; ++i )
  {
     //Allocate a position per threads.
     position_t* position = new position_t();

     //Set position values.
     position->x = ( 1 + i ) * 11;
     position->y = ( 1 + i ) * 13;

     //Create the thread.
     result = pthread_create( &threads[i], NULL, the_thread, position );
  }

  //Give time for threads to enter their forever loop.
  sleep( 5 );

  //Abort.
  abort();
  return 0; 
}

void* the_thread( void* position )
{
   int result = pthread_setspecific( position_key, position );

   printf( "Thread: 0x%.8x, key: %u, value: 0x%.8x, result: %i\n",
           pthread_self(), position_key, position, result );

   get_position();
   return 0;
}

void get_position()
{
   position_t* position =
        reinterpret_cast< position_t* >( pthread_getspecific( position_key ) );

   printf( "Thread: 0x%.8x, key: %u, position: 0x%.8x, x: %i, y: %i\n",
           pthread_self(), position_key, position, position->x, position->y );

   //Wait forever.
   while( true ) {};
}

$ g++ -g -lpthread example.cpp && gdb -q ./a.out 
Using host libthread_db library "/lib/libthread_db.so.1".
(gdb) r
Starting program: /tmp/a.out 
[Thread debugging using libthread_db enabled]
[New Thread -1209043248 (LWP 17390)]
pthread_key_create -- key: 0, result: 0
[New Thread -1209046128 (LWP 17393)]
Thread: 0xb7ef6b90, key: 0, value: 0x09a35008, result: 0
Thread: 0xb7ef6b90, key: 0, position: 0x09a35008, x: 11, y: 13
[New Thread -1219535984 (LWP 17394)]
Thread: 0xb74f5b90, key: 0, value: 0x09a350b0, result: 0
Thread: 0xb74f5b90, key: 0, position: 0x09a350b0, x: 22, y: 26

Program received signal SIGABRT, Aborted.
[Switching to Thread -1209043248 (LWP 17390)]
0x00377402 in __kernel_vsyscall ()

---

Mit Adressen noch auf dem Stapel:

(gdb) info threads
  3 Thread -1219535984 (LWP 17394)  get_position () at example.cpp:71
  2 Thread -1209046128 (LWP 17393)  get_position () at example.cpp:71
* 1 Thread -1209043248 (LWP 17390)  0x00377402 in __kernel_vsyscall ()
(gdb) thread 3
[Switching to thread 3 (Thread -1219535984 (LWP 17394))]#0  get_position () 
 at example.cpp:71
71         while( true ) {};
(gdb) list get_position
57
58         get_position();
59         return 0;
60      }
61       
62      void get_position()
63      {
64         position_t* position =
65              reinterpret_cast< position_t* >( pthread_getspecific( 
 position_key ) );
66
(gdb) info locals
position = (position_t *) 0x9a350b0
(gdb) p position->x
$1 = 22
(gdb) p position->y
$2 = 26

---

Mit Adressen gedruckt von stdout:

(gdb) p ((position_t*)(0x09a350b0))->x 
$3 = 22
(gdb) p ((position_t*)(0x09a350b0))->y
$4 = 26

---

Suchen Sie die thread-spezifische Daten Liste innerhalb des threads interne Daten:

Dieser Ansatz ist viel einfacher, wenn Sie den Wert key und pthread_t.

Stelle ich details über die pthread-Implementierung, die ich verwende, sobald Sie benötigt werden:

• pthread struct thread-descriptor-Struktur, die intern von pthread.
• pthread_create() zurück pthread_t eine unsigned int enthält die Adresse des zugehörigen pthread struct.

Suchen Sie zuerst den pthread struct für den thread.

(gdb) info threads
* 3 Thread -1219535984 (LWP 17394)  get_position () at example.cpp:71
  2 Thread -1209046128 (LWP 17393)  get_position () at example.cpp:71
  1 Thread -1209043248 (LWP 17390)  0x00377402 in __kernel_vsyscall ()
(gdb) thread 1
[Switching to thread 1 (Thread -1209043248 (LWP 17390))]#0  0x00377402 in
 __kernel_vsyscall ()
(gdb) bt
#0  0x00377402 in __kernel_vsyscall ()
#1  0x0080ec10 in raise () from /lib/libc.so.6
#2  0x00810521 in abort () from /lib/libc.so.6
#3  0x0804880f in main () at example.cpp:47
(gdb) frame 3
#3  0x0804880f in main () at example.cpp:47
47        abort();
(gdb) info locals
result = 0
threads = {3085921168, 3075431312}
(gdb) p/x threads[1]
$5 = 0xb74f5b90

Ignoriert viele der Felder, die pthread struct-definition sieht wie folgt aus:

struct pthread
{
  ...
  pid_t tid; //Thread ID (i.e. this thread descriptor).
  pid_t pid; //Process ID.
  ...
  struct pthread_key_data
  {
    uintptr_t seq;
    void *data;
  } specific_1stblock[PTHREAD_KEY_2NDLEVEL_SIZE];
  struct pthread_key_data *specific[PTHREAD_KEY_1STLEVEL_SIZE];
  ...
};

• pthread_key_data.seq : enthält die laufende Nummer, die sollte relativ niedrig und entsprechen __pthread_keys[key].seq.
• pthread_key_data.data : enthält den Wert zur Verfügung gestellt pthread_setspecific()
• pthread.specific_1stblock ist ein block, der verwendet wird zum speichern von thread-spezifischen Daten, bevor Sie versuchen, um dynamisch die Zuweisung von mehr Blöcke.
• pthread ist ein zwei-Ebenen-array für thread-spezifische Daten. Index 0 enthält die Speicheradresse des pthread.specific_1stblock.
• PTHREAD_KEY_2NDLEVEL_SIZE hat eine Größe von 32.

Die definition gibt eine ziemlich gute Vorstellung davon, was Sie suchen in Speicher:

• Eine ganze Zahl mit einem Wert von pthread Speicher-Adresse (tid), gefolgt von einem integer mit der Prozess-id (pid). Dies ist hilfreich um anzuzeigen, ob der Speicher geprüft ist ein pthread struct.
• cancelhandling und flags sind Fahnen. Die spezifischen Werte sind nicht wichtig. Diese Felder können hilfreich sein, da Ihre Werte sind potenziell sichtlich unterscheidbar von anderen Bereichen, wie zum Beispiel solche mit Speicher-Adressen oder Zähler.
• specific_1stblock ist ein array der Größe 32. Wenn die pthread struct hat null initialisiert, dann sollte es wiederholen 0s für 62~ Worte, weil der Beispiel-code hat nur eine thread-spezifische Daten position_key mit einer Größe von zwei Wörtern.
• specific ist ein array von Speicher-Adressen. Wenn die pthread struct hat null initialisiert, dann sollte es wiederholen 0s, aber der erste Wert sollte die Speicher-Adresse von specific_1stblock.

Print ein Stück pthread's Speicher:

(gdb) p/x *((int*)threads[1])@150
$6 = {0xb74f5b90, 0x9a350c8, 0xb74f5b90, 0x1, 0x377400, 0x7fb99100,
  0xcb40329e, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb7ef6bd0,
  0x96b118, 0x43f2, 0x43ee, 0xb74f5be0, 0xffffffec, 0x0, 0x0, 0xb74f5470,
  0x0, 0x1, 0x9a350b0, 0x0 <repeats 62 times>, 0xb74f5bf8,
  0x0 <repeats 31 times>, 0x1000101, 0x0, 0x0, 0x0, 0xc2342345, 0xe0286,
  0x0, 0x0, 0x0, 0x0, 0x0, 0x80486ca, 0x9a350b0, 0x0 <repeats 13 times>, 
  0xb6af5000, 0xa01000}

Durch analyizing Muster in den Speicher, einige Worte zu guten Kandidaten für eine bestimmte pthread-Felder:

0xb74f5b90, 0x9a350c8, 0xb74f5b90 (pthread.tid), 0x1, 0x377400 (pthread.pid) ...
0x1, 0x9a350b0, 0x0 <repeats 62 times> (pthread.specific_1stblock) ...
0xb74f5bf8, 0x0 <repeats 31 times>  (pthread.specific)

Etwas Licht-Gewicht-Plausibilitätsprüfungen können durchgeführt werden, wie etwa die überprüfung, ob pthread.specific[0] enthält die Adresse des pthread.specific_1stblock:

(gdb) p/x *((int*)0xb74f5bf8)@64
$7 = {0x1, 0x9a350b0, 0x0 <repeats 62 times>} ## matches specific_1stblock

Nun, dass pthread.specific identifiziert wurde, erhalten Sie Ihre memory-Adresse durch das zählen der Wort-offset von &pthread. In diesem Fall ist es 90:

(gdb) set $specific=(int*)threads[1] + 90

Berechnen Sie die erste und zweite index über position_key:

• Der index für das erste array ist key /PTHREAD_KEY_2NDLEVEL_SIZE.

• Index in der zweiten Reihe ist key % PTHREAD_KEY_2NDLEVEL_SIZE.

  (gdb) set $index1=position_key/32
  (gdb) set $index2=position_key%32
  

Suchen Sie die pthread_key_data für position_key:

(gdb) set $level2=(int*)*($specific + $index1)
(gdb) p/x *($level2 + (2*$index2))@2
$8 = {0x1, 0x9a350b0}

Also:

pthread_key_data.seq = 1

pthread_key_data.data = 0x9a350b0

Das erste Wort ist das seq die sollten übereinstimmen pthread_key_struct[position_key].seq. Durch den Umgang mit raw-Speicher, __pthread_keys wird gegossen, um int* - und Zeiger-Arithmetik wird erfolgen müssen, um eine Rechnung für den sizeof -pthread_key_struct:

(gdb) p *(&((int*)&__pthread_keys)[2*position_key])@2
$9 = {1, 0}

Also:

pthread_key_struct[position_key].seq = 1

pthread_key_struct[position_key].destr = NULL

Den seq zahlen übereinstimmen, also alles sieht gut aus. pthread_key_data.data enthält den Wert, der zurückgegeben werden von pthread_getspecific( position_key ).

(gdb) set $position=(position_t*)0x9a350b0
(gdb) p $position->x
$10 = 22
(gdb) p $position->y
$11 = 26

---

Ist es technisch immer noch möglich ist, suchen Sie thread-spezifische Daten, ohne Kenntnis der key und pthread_t Werte:

• Wenn eine Destruktor-Funktion wurde bereitgestellt, um pthread_key_create() dann seine Speicher-Adresse möglicherweise gespeichert wird innerhalb der __pthread_keys array. Untersuchen Sie den Speicher, und berechnen Sie den offset und dividieren durch den sizeof -pthread_key_struct. Das Ergebnis ist der index, der zufällig auch der Schlüssel:

  void* destr_fn( void* );
  pthread_key_create( key, destr_fn )
  __pthread_keys[key].destr == destr_fn
  

• Wenn die pthread_t unbekannt ist, kann es existiert innerhalb eines Registers auf den Stapel des Threads. Dies kann erfordern, die Prüfung der verschiedenen Speicher-Adressen, die versuchen, suchen Sie einen Abschnitt im Speicher, enthält die pthread struct.

  (gdb) info thread
    3 Thread -1219535984 (LWP 17394)  get_position () at example.cpp:71
    2 Thread -1209046128 (LWP 17393)  get_position () at example.cpp:71
  * 1 Thread -1209043248 (LWP 17390)  0x00377402 in __kernel_vsyscall ()
  (gdb) thread 3
  [Switching to thread 3 (Thread -1219535984 (LWP 17394))]#0 g
   get_position () at example.cpp:71
  71         while( true ) {};
  (gdb) bt
  #0  get_position () at example.cpp:71
  #1  0x0804871d in the_thread (position=0x9a350b0) at example.cpp:58
  #2  0x0095c43b in start_thread () from /lib/libpthread.so.0
  #3  0x008b3fde in clone () from /lib/libc.so.6
  (gdb) frame 2
  #2  0x0095c43b in start_thread () from /lib/libpthread.so.0
  (gdb) info register
  eax            0x3f     63
  ecx            0xb74f52ac       -1219538260
  edx            0x0      0
  ebx            0x96aff4 9875444
  esp            0xb74f53c0       0xb74f53c0
  ebp            0xb74f54a8       0xb74f54a8
  esi            0x0      0
  edi            0xb74f5b90       -1219535984
  eip            0x95c43b 0x95c43b <start_thread+203>
  eflags         0x200286 [ PF SF IF ID ]
  cs             0x73     115
  ss             0x7b     123
  ds             0x7b     123
  es             0x7b     123
  fs             0x0      0
  gs             0x33     51
  

  In diesem Fall, die edi - register enthält die Adresse des pthread struct.

Referenzen: descr.h, pthread_key_create.c, pthread_setspecific.c, pthreadP.h, internaltypes.h