gdb/gdbserver/thread-db.c

   1 /* Thread management interface, for the remote server for GDB.
   2    Copyright (C) 2002, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
   3
   4    Contributed by MontaVista Software.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "server.h"
  22
  23 #include "linux-low.h"
  24
  25 extern int debug_threads;
  26
  27 static int thread_db_use_events;
  28
  29 #ifdef HAVE_THREAD_DB_H
  30 #include <thread_db.h>
  31 #endif
  32
  33 #include "gdb_proc_service.h"
  34
  35 #include <stdint.h>
  36
  37 /* Structure that identifies the child process for the
  38    <proc_service.h> interface.  */
  39 static struct ps_prochandle proc_handle;
  40
  41 /* Connection to the libthread_db library.  */
  42 static td_thragent_t *thread_agent;
  43
  44 static int find_one_thread (int);
  45 static int find_new_threads_callback (const td_thrhandle_t *th_p, void *data);
  46
  47 static char *
  48 thread_db_err_str (td_err_e err)
  49 {
  50   static char buf[64];
  51
  52   switch (err)
  53     {
  54     case TD_OK:
  55       return "generic 'call succeeded'";
  56     case TD_ERR:
  57       return "generic error";
  58     case TD_NOTHR:
  59       return "no thread to satisfy query";
  60     case TD_NOSV:
  61       return "no sync handle to satisfy query";
  62     case TD_NOLWP:
  63       return "no LWP to satisfy query";
  64     case TD_BADPH:
  65       return "invalid process handle";
  66     case TD_BADTH:
  67       return "invalid thread handle";
  68     case TD_BADSH:
  69       return "invalid synchronization handle";
  70     case TD_BADTA:
  71       return "invalid thread agent";
  72     case TD_BADKEY:
  73       return "invalid key";
  74     case TD_NOMSG:
  75       return "no event message for getmsg";
  76     case TD_NOFPREGS:
  77       return "FPU register set not available";
  78     case TD_NOLIBTHREAD:
  79       return "application not linked with libthread";
  80     case TD_NOEVENT:
  81       return "requested event is not supported";
  82     case TD_NOCAPAB:
  83       return "capability not available";
  84     case TD_DBERR:
  85       return "debugger service failed";
  86     case TD_NOAPLIC:
  87       return "operation not applicable to";
  88     case TD_NOTSD:
  89       return "no thread-specific data for this thread";
  90     case TD_MALLOC:
  91       return "malloc failed";
  92     case TD_PARTIALREG:
  93       return "only part of register set was written/read";
  94     case TD_NOXREGS:
  95       return "X register set not available for this thread";
  96 #ifdef HAVE_TD_VERSION
  97     case TD_VERSION:
  98       return "version mismatch between libthread_db and libpthread";
  99 #endif
 100     default:
 101       snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err);
 102       return buf;
 103     }
 104 }
 105
 106 #if 0
 107 static char *
 108 thread_db_state_str (td_thr_state_e state)
 109 {
 110   static char buf[64];
 111
 112   switch (state)
 113     {
 114     case TD_THR_STOPPED:
 115       return "stopped by debugger";
 116     case TD_THR_RUN:
 117       return "runnable";
 118     case TD_THR_ACTIVE:
 119       return "active";
 120     case TD_THR_ZOMBIE:
 121       return "zombie";
 122     case TD_THR_SLEEP:
 123       return "sleeping";
 124     case TD_THR_STOPPED_ASLEEP:
 125       return "stopped by debugger AND blocked";
 126     default:
 127       snprintf (buf, sizeof (buf), "unknown thread_db state %d", state);
 128       return buf;
 129     }
 130 }
 131 #endif
 132
 133 static void
 134 thread_db_create_event (CORE_ADDR where)
 135 {
 136   td_event_msg_t msg;
 137   td_err_e err;
 138   struct process_info *process;
 139
 140   if (debug_threads)
 141     fprintf (stderr, "Thread creation event.\n");
 142
 143   /* FIXME: This assumes we don't get another event.
 144      In the LinuxThreads implementation, this is safe,
 145      because all events come from the manager thread
 146      (except for its own creation, of course).  */
 147   err = td_ta_event_getmsg (thread_agent, &msg);
 148   if (err != TD_OK)
 149     fprintf (stderr, "thread getmsg err: %s\n",
 150              thread_db_err_str (err));
 151
 152   /* If we do not know about the main thread yet, this would be a good time to
 153      find it.  We need to do this to pick up the main thread before any newly
 154      created threads.  */
 155   process = get_thread_process (current_inferior);
 156   if (process->thread_known == 0)
 157     find_one_thread (process->lwpid);
 158
 159   /* msg.event == TD_EVENT_CREATE */
 160
 161   find_new_threads_callback (msg.th_p, NULL);
 162 }
 163
 164 #if 0
 165 static void
 166 thread_db_death_event (CORE_ADDR where)
 167 {
 168   if (debug_threads)
 169     fprintf (stderr, "Thread death event.\n");
 170 }
 171 #endif
 172
 173 static int
 174 thread_db_enable_reporting ()
 175 {
 176   td_thr_events_t events;
 177   td_notify_t notify;
 178   td_err_e err;
 179
 180   /* Set the process wide mask saying which events we're interested in.  */
 181   td_event_emptyset (&events);
 182   td_event_addset (&events, TD_CREATE);
 183
 184 #if 0
 185   /* This is reported to be broken in glibc 2.1.3.  A different approach
 186      will be necessary to support that.  */
 187   td_event_addset (&events, TD_DEATH);
 188 #endif
 189
 190   err = td_ta_set_event (thread_agent, &events);
 191   if (err != TD_OK)
 192     {
 193       warning ("Unable to set global thread event mask: %s",
 194                thread_db_err_str (err));
 195       return 0;
 196     }
 197
 198   /* Get address for thread creation breakpoint.  */
 199   err = td_ta_event_addr (thread_agent, TD_CREATE, &notify);
 200   if (err != TD_OK)
 201     {
 202       warning ("Unable to get location for thread creation breakpoint: %s",
 203                thread_db_err_str (err));
 204       return 0;
 205     }
 206   set_breakpoint_at ((CORE_ADDR) (unsigned long) notify.u.bptaddr,
 207                      thread_db_create_event);
 208
 209 #if 0
 210   /* Don't concern ourselves with reported thread deaths, only
 211      with actual thread deaths (via wait).  */
 212
 213   /* Get address for thread death breakpoint.  */
 214   err = td_ta_event_addr (thread_agent, TD_DEATH, &notify);
 215   if (err != TD_OK)
 216     {
 217       warning ("Unable to get location for thread death breakpoint: %s",
 218                thread_db_err_str (err));
 219       return;
 220     }
 221   set_breakpoint_at ((CORE_ADDR) (unsigned long) notify.u.bptaddr,
 222                      thread_db_death_event);
 223 #endif
 224
 225   return 1;
 226 }
 227
 228 static int
 229 find_one_thread (int lwpid)
 230 {
 231   td_thrhandle_t th;
 232   td_thrinfo_t ti;
 233   td_err_e err;
 234   struct thread_info *inferior;
 235   struct process_info *process;
 236
 237   inferior = (struct thread_info *) find_inferior_id (&all_threads, lwpid);
 238   process = get_thread_process (inferior);
 239   if (process->thread_known)
 240     return 1;
 241
 242   /* Get information about this thread.  */
 243   err = td_ta_map_lwp2thr (thread_agent, process->lwpid, &th);
 244   if (err != TD_OK)
 245     error ("Cannot get thread handle for LWP %d: %s",
 246            lwpid, thread_db_err_str (err));
 247
 248   err = td_thr_get_info (&th, &ti);
 249   if (err != TD_OK)
 250     error ("Cannot get thread info for LWP %d: %s",
 251            lwpid, thread_db_err_str (err));
 252
 253   if (debug_threads)
 254     fprintf (stderr, "Found thread %ld (LWP %d)\n",
 255              ti.ti_tid, ti.ti_lid);
 256
 257   if (process->lwpid != ti.ti_lid)
 258     {
 259       warning ("PID mismatch!  Expected %ld, got %ld",
 260                (long) process->lwpid, (long) ti.ti_lid);
 261       return 0;
 262     }
 263
 264   if (thread_db_use_events)
 265     {
 266       err = td_thr_event_enable (&th, 1);
 267       if (err != TD_OK)
 268         error ("Cannot enable thread event reporting for %d: %s",
 269                ti.ti_lid, thread_db_err_str (err));
 270     }
 271
 272   /* If the new thread ID is zero, a final thread ID will be available
 273      later.  Do not enable thread debugging yet.  */
 274   if (ti.ti_tid == 0)
 275     return 0;
 276
 277   process->thread_known = 1;
 278   process->tid = ti.ti_tid;
 279   process->th = th;
 280
 281   return 1;
 282 }
 283
 284 static void
 285 maybe_attach_thread (const td_thrhandle_t *th_p, td_thrinfo_t *ti_p)
 286 {
 287   td_err_e err;
 288   struct thread_info *inferior;
 289   struct process_info *process;
 290
 291   inferior = (struct thread_info *) find_inferior_id (&all_threads,
 292                                                       ti_p->ti_lid);
 293   if (inferior != NULL)
 294     return;
 295
 296   if (debug_threads)
 297     fprintf (stderr, "Attaching to thread %ld (LWP %d)\n",
 298              ti_p->ti_tid, ti_p->ti_lid);
 299   linux_attach_lwp (ti_p->ti_lid);
 300   inferior = (struct thread_info *) find_inferior_id (&all_threads,
 301                                                       ti_p->ti_lid);
 302   if (inferior == NULL)
 303     {
 304       warning ("Could not attach to thread %ld (LWP %d)\n",
 305                ti_p->ti_tid, ti_p->ti_lid);
 306       return;
 307     }
 308
 309   process = inferior_target_data (inferior);
 310
 311   process->tid = ti_p->ti_tid;
 312   process->thread_known = 1;
 313   process->th = *th_p;
 314
 315   if (thread_db_use_events)
 316     {
 317       err = td_thr_event_enable (th_p, 1);
 318       if (err != TD_OK)
 319         error ("Cannot enable thread event reporting for %d: %s",
 320                ti_p->ti_lid, thread_db_err_str (err));
 321     }
 322 }
 323
 324 static int
 325 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
 326 {
 327   td_thrinfo_t ti;
 328   td_err_e err;
 329
 330   err = td_thr_get_info (th_p, &ti);
 331   if (err != TD_OK)
 332     error ("Cannot get thread info: %s", thread_db_err_str (err));
 333
 334   /* Check for zombies.  */
 335   if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
 336     return 0;
 337
 338   maybe_attach_thread (th_p, &ti);
 339
 340   return 0;
 341 }
 342
 343 static void
 344 thread_db_find_new_threads (void)
 345 {
 346   td_err_e err;
 347
 348   /* This function is only called when we first initialize thread_db.
 349      First locate the initial thread.  If it is not ready for
 350      debugging yet, then stop.  */
 351   if (find_one_thread (all_threads.head->id) == 0)
 352     return;
 353
 354   /* Iterate over all user-space threads to discover new threads.  */
 355   err = td_ta_thr_iter (thread_agent, find_new_threads_callback, NULL,
 356                         TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
 357                         TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
 358   if (err != TD_OK)
 359     error ("Cannot find new threads: %s", thread_db_err_str (err));
 360 }
 361
 362 /* Cache all future symbols that thread_db might request.  We can not
 363    request symbols at arbitrary states in the remote protocol, only
 364    when the client tells us that new symbols are available.  So when
 365    we load the thread library, make sure to check the entire list.  */
 366
 367 static void
 368 thread_db_look_up_symbols (void)
 369 {
 370   const char **sym_list = td_symbol_list ();
 371   CORE_ADDR unused;
 372
 373   for (sym_list = td_symbol_list (); *sym_list; sym_list++)
 374     look_up_one_symbol (*sym_list, &unused);
 375 }
 376
 377 int
 378 thread_db_get_tls_address (struct thread_info *thread, CORE_ADDR offset,
 379                            CORE_ADDR load_module, CORE_ADDR *address)
 380 {
 381 #if HAVE_TD_THR_TLS_GET_ADDR
 382   psaddr_t addr;
 383   td_err_e err;
 384   struct process_info *process;
 385
 386   process = get_thread_process (thread);
 387   if (!process->thread_known)
 388     find_one_thread (process->lwpid);
 389   if (!process->thread_known)
 390     return TD_NOTHR;
 391
 392   /* Note the cast through uintptr_t: this interface only works if
 393      a target address fits in a psaddr_t, which is a host pointer.
 394      So a 32-bit debugger can not access 64-bit TLS through this.  */
 395   err = td_thr_tls_get_addr (&process->th, (psaddr_t) (uintptr_t) load_module,
 396                              offset, &addr);
 397   if (err == TD_OK)
 398     {
 399       *address = (CORE_ADDR) (uintptr_t) addr;
 400       return 0;
 401     }
 402   else
 403     return err;
 404 #else
 405   return -1;
 406 #endif
 407 }
 408
 409 int
 410 thread_db_init (int use_events)
 411 {
 412   int err;
 413
 414   /* FIXME drow/2004-10-16: This is the "overall process ID", which
 415      GNU/Linux calls tgid, "thread group ID".  When we support
 416      attaching to threads, the original thread may not be the correct
 417      thread.  We would have to get the process ID from /proc for NPTL.
 418      For LinuxThreads we could do something similar: follow the chain
 419      of parent processes until we find the highest one we're attached
 420      to, and use its tgid.
 421
 422      This isn't the only place in gdbserver that assumes that the first
 423      process in the list is the thread group leader.  */
 424   proc_handle.pid = ((struct inferior_list_entry *)current_inferior)->id;
 425
 426   /* Allow new symbol lookups.  */
 427   all_symbols_looked_up = 0;
 428
 429   thread_db_use_events = use_events;
 430
 431   err = td_ta_new (&proc_handle, &thread_agent);
 432   switch (err)
 433     {
 434     case TD_NOLIBTHREAD:
 435       /* No thread library was detected.  */
 436       return 0;
 437
 438     case TD_OK:
 439       /* The thread library was detected.  */
 440
 441       if (use_events && thread_db_enable_reporting () == 0)
 442         return 0;
 443       thread_db_find_new_threads ();
 444       thread_db_look_up_symbols ();
 445       all_symbols_looked_up = 1;
 446       return 1;
 447
 448     default:
 449       warning ("error initializing thread_db library: %s",
 450                thread_db_err_str (err));
 451     }
 452
 453   return 0;
 454 }