gdb/gdbserver/thread-db.c

   1 /* Thread management interface, for the remote server for GDB.
   2    Copyright (C) 2002-2013 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 #include "gdb_proc_service.h"
  30 #include "gdb_thread_db.h"
  31 #include "gdb_vecs.h"
  32
  33 #ifndef USE_LIBTHREAD_DB_DIRECTLY
  34 #include <dlfcn.h>
  35 #endif
  36
  37 #include <stdint.h>
  38 #include <limits.h>
  39 #include <ctype.h>
  40
  41 struct thread_db
  42 {
  43   /* Structure that identifies the child process for the
  44      <proc_service.h> interface.  */
  45   struct ps_prochandle proc_handle;
  46
  47   /* Connection to the libthread_db library.  */
  48   td_thragent_t *thread_agent;
  49
  50   /* If this flag has been set, we've already asked GDB for all
  51      symbols we might need; assume symbol cache misses are
  52      failures.  */
  53   int all_symbols_looked_up;
  54
  55 #ifndef USE_LIBTHREAD_DB_DIRECTLY
  56   /* Handle of the libthread_db from dlopen.  */
  57   void *handle;
  58 #endif
  59
  60   /* Thread creation event breakpoint.  The code at this location in
  61      the child process will be called by the pthread library whenever
  62      a new thread is created.  By setting a special breakpoint at this
  63      location, GDB can detect when a new thread is created.  We obtain
  64      this location via the td_ta_event_addr call.  Note that if the
  65      running kernel supports tracing clones, then we don't need to use
  66      (and in fact don't use) this magic thread event breakpoint to
  67      learn about threads.  */
  68   struct breakpoint *td_create_bp;
  69
  70   /* Addresses of libthread_db functions.  */
  71   td_err_e (*td_ta_new_p) (struct ps_prochandle * ps, td_thragent_t **ta);
  72   td_err_e (*td_ta_event_getmsg_p) (const td_thragent_t *ta,
  73                                     td_event_msg_t *msg);
  74   td_err_e (*td_ta_set_event_p) (const td_thragent_t *ta,
  75                                  td_thr_events_t *event);
  76   td_err_e (*td_ta_event_addr_p) (const td_thragent_t *ta,
  77                                   td_event_e event, td_notify_t *ptr);
  78   td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta, lwpid_t lwpid,
  79                                    td_thrhandle_t *th);
  80   td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th,
  81                                  td_thrinfo_t *infop);
  82   td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th, int event);
  83   td_err_e (*td_ta_thr_iter_p) (const td_thragent_t *ta,
  84                                 td_thr_iter_f *callback, void *cbdata_p,
  85                                 td_thr_state_e state, int ti_pri,
  86                                 sigset_t *ti_sigmask_p,
  87                                 unsigned int ti_user_flags);
  88   td_err_e (*td_thr_tls_get_addr_p) (const td_thrhandle_t *th,
  89                                      psaddr_t map_address,
  90                                      size_t offset, psaddr_t *address);
  91   const char ** (*td_symbol_list_p) (void);
  92 };
  93
  94 static char *libthread_db_search_path;
  95
  96 static int find_one_thread (ptid_t);
  97 static int find_new_threads_callback (const td_thrhandle_t *th_p, void *data);
  98
  99 static const char *
 100 thread_db_err_str (td_err_e err)
 101 {
 102   static char buf[64];
 103
 104   switch (err)
 105     {
 106     case TD_OK:
 107       return "generic 'call succeeded'";
 108     case TD_ERR:
 109       return "generic error";
 110     case TD_NOTHR:
 111       return "no thread to satisfy query";
 112     case TD_NOSV:
 113       return "no sync handle to satisfy query";
 114     case TD_NOLWP:
 115       return "no LWP to satisfy query";
 116     case TD_BADPH:
 117       return "invalid process handle";
 118     case TD_BADTH:
 119       return "invalid thread handle";
 120     case TD_BADSH:
 121       return "invalid synchronization handle";
 122     case TD_BADTA:
 123       return "invalid thread agent";
 124     case TD_BADKEY:
 125       return "invalid key";
 126     case TD_NOMSG:
 127       return "no event message for getmsg";
 128     case TD_NOFPREGS:
 129       return "FPU register set not available";
 130     case TD_NOLIBTHREAD:
 131       return "application not linked with libthread";
 132     case TD_NOEVENT:
 133       return "requested event is not supported";
 134     case TD_NOCAPAB:
 135       return "capability not available";
 136     case TD_DBERR:
 137       return "debugger service failed";
 138     case TD_NOAPLIC:
 139       return "operation not applicable to";
 140     case TD_NOTSD:
 141       return "no thread-specific data for this thread";
 142     case TD_MALLOC:
 143       return "malloc failed";
 144     case TD_PARTIALREG:
 145       return "only part of register set was written/read";
 146     case TD_NOXREGS:
 147       return "X register set not available for this thread";
 148 #ifdef HAVE_TD_VERSION
 149     case TD_VERSION:
 150       return "version mismatch between libthread_db and libpthread";
 151 #endif
 152     default:
 153       xsnprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err);
 154       return buf;
 155     }
 156 }
 157
 158 #if 0
 159 static char *
 160 thread_db_state_str (td_thr_state_e state)
 161 {
 162   static char buf[64];
 163
 164   switch (state)
 165     {
 166     case TD_THR_STOPPED:
 167       return "stopped by debugger";
 168     case TD_THR_RUN:
 169       return "runnable";
 170     case TD_THR_ACTIVE:
 171       return "active";
 172     case TD_THR_ZOMBIE:
 173       return "zombie";
 174     case TD_THR_SLEEP:
 175       return "sleeping";
 176     case TD_THR_STOPPED_ASLEEP:
 177       return "stopped by debugger AND blocked";
 178     default:
 179       xsnprintf (buf, sizeof (buf), "unknown thread_db state %d", state);
 180       return buf;
 181     }
 182 }
 183 #endif
 184
 185 static int
 186 thread_db_create_event (CORE_ADDR where)
 187 {
 188   td_event_msg_t msg;
 189   td_err_e err;
 190   struct lwp_info *lwp;
 191   struct thread_db *thread_db = current_process ()->private->thread_db;
 192
 193   if (thread_db->td_ta_event_getmsg_p == NULL)
 194     fatal ("unexpected thread_db->td_ta_event_getmsg_p == NULL");
 195
 196   if (debug_threads)
 197     fprintf (stderr, "Thread creation event.\n");
 198
 199   /* FIXME: This assumes we don't get another event.
 200      In the LinuxThreads implementation, this is safe,
 201      because all events come from the manager thread
 202      (except for its own creation, of course).  */
 203   err = thread_db->td_ta_event_getmsg_p (thread_db->thread_agent, &msg);
 204   if (err != TD_OK)
 205     fprintf (stderr, "thread getmsg err: %s\n",
 206              thread_db_err_str (err));
 207
 208   /* If we do not know about the main thread yet, this would be a good time to
 209      find it.  We need to do this to pick up the main thread before any newly
 210      created threads.  */
 211   lwp = get_thread_lwp (current_inferior);
 212   if (lwp->thread_known == 0)
 213     find_one_thread (lwp->head.id);
 214
 215   /* msg.event == TD_EVENT_CREATE */
 216
 217   find_new_threads_callback (msg.th_p, NULL);
 218
 219   return 0;
 220 }
 221
 222 static int
 223 thread_db_enable_reporting (void)
 224 {
 225   td_thr_events_t events;
 226   td_notify_t notify;
 227   td_err_e err;
 228   struct thread_db *thread_db = current_process ()->private->thread_db;
 229
 230   if (thread_db->td_ta_set_event_p == NULL
 231       || thread_db->td_ta_event_addr_p == NULL
 232       || thread_db->td_ta_event_getmsg_p == NULL)
 233     /* This libthread_db is missing required support.  */
 234     return 0;
 235
 236   /* Set the process wide mask saying which events we're interested in.  */
 237   td_event_emptyset (&events);
 238   td_event_addset (&events, TD_CREATE);
 239
 240   err = thread_db->td_ta_set_event_p (thread_db->thread_agent, &events);
 241   if (err != TD_OK)
 242     {
 243       warning ("Unable to set global thread event mask: %s",
 244                thread_db_err_str (err));
 245       return 0;
 246     }
 247
 248   /* Get address for thread creation breakpoint.  */
 249   err = thread_db->td_ta_event_addr_p (thread_db->thread_agent, TD_CREATE,
 250                                        &notify);
 251   if (err != TD_OK)
 252     {
 253       warning ("Unable to get location for thread creation breakpoint: %s",
 254                thread_db_err_str (err));
 255       return 0;
 256     }
 257   thread_db->td_create_bp
 258     = set_breakpoint_at ((CORE_ADDR) (unsigned long) notify.u.bptaddr,
 259                          thread_db_create_event);
 260
 261   return 1;
 262 }
 263
 264 static int
 265 find_one_thread (ptid_t ptid)
 266 {
 267   td_thrhandle_t th;
 268   td_thrinfo_t ti;
 269   td_err_e err;
 270   struct thread_info *inferior;
 271   struct lwp_info *lwp;
 272   struct thread_db *thread_db = current_process ()->private->thread_db;
 273   int lwpid = ptid_get_lwp (ptid);
 274
 275   inferior = (struct thread_info *) find_inferior_id (&all_threads, ptid);
 276   lwp = get_thread_lwp (inferior);
 277   if (lwp->thread_known)
 278     return 1;
 279
 280   /* Get information about this thread.  */
 281   err = thread_db->td_ta_map_lwp2thr_p (thread_db->thread_agent, lwpid, &th);
 282   if (err != TD_OK)
 283     error ("Cannot get thread handle for LWP %d: %s",
 284            lwpid, thread_db_err_str (err));
 285
 286   err = thread_db->td_thr_get_info_p (&th, &ti);
 287   if (err != TD_OK)
 288     error ("Cannot get thread info for LWP %d: %s",
 289            lwpid, thread_db_err_str (err));
 290
 291   if (debug_threads)
 292     fprintf (stderr, "Found thread %ld (LWP %d)\n",
 293              ti.ti_tid, ti.ti_lid);
 294
 295   if (lwpid != ti.ti_lid)
 296     {
 297       warning ("PID mismatch!  Expected %ld, got %ld",
 298                (long) lwpid, (long) ti.ti_lid);
 299       return 0;
 300     }
 301
 302   if (thread_db_use_events)
 303     {
 304       err = thread_db->td_thr_event_enable_p (&th, 1);
 305       if (err != TD_OK)
 306         error ("Cannot enable thread event reporting for %d: %s",
 307                ti.ti_lid, thread_db_err_str (err));
 308     }
 309
 310   /* If the new thread ID is zero, a final thread ID will be available
 311      later.  Do not enable thread debugging yet.  */
 312   if (ti.ti_tid == 0)
 313     return 0;
 314
 315   lwp->thread_known = 1;
 316   lwp->th = th;
 317
 318   return 1;
 319 }
 320
 321 /* Attach a thread.  Return true on success.  */
 322
 323 static int
 324 attach_thread (const td_thrhandle_t *th_p, td_thrinfo_t *ti_p)
 325 {
 326   struct lwp_info *lwp;
 327
 328   if (debug_threads)
 329     fprintf (stderr, "Attaching to thread %ld (LWP %d)\n",
 330              ti_p->ti_tid, ti_p->ti_lid);
 331   linux_attach_lwp (ti_p->ti_lid);
 332   lwp = find_lwp_pid (pid_to_ptid (ti_p->ti_lid));
 333   if (lwp == NULL)
 334     {
 335       warning ("Could not attach to thread %ld (LWP %d)\n",
 336                ti_p->ti_tid, ti_p->ti_lid);
 337       return 0;
 338     }
 339
 340   lwp->thread_known = 1;
 341   lwp->th = *th_p;
 342
 343   if (thread_db_use_events)
 344     {
 345       td_err_e err;
 346       struct thread_db *thread_db = current_process ()->private->thread_db;
 347
 348       err = thread_db->td_thr_event_enable_p (th_p, 1);
 349       if (err != TD_OK)
 350         error ("Cannot enable thread event reporting for %d: %s",
 351                ti_p->ti_lid, thread_db_err_str (err));
 352     }
 353
 354   return 1;
 355 }
 356
 357 /* Attach thread if we haven't seen it yet.
 358    Increment *COUNTER if we have attached a new thread.
 359    Return false on failure.  */
 360
 361 static int
 362 maybe_attach_thread (const td_thrhandle_t *th_p, td_thrinfo_t *ti_p,
 363                      int *counter)
 364 {
 365   struct lwp_info *lwp;
 366
 367   lwp = find_lwp_pid (pid_to_ptid (ti_p->ti_lid));
 368   if (lwp != NULL)
 369     return 1;
 370
 371   if (!attach_thread (th_p, ti_p))
 372     return 0;
 373
 374   if (counter != NULL)
 375     *counter += 1;
 376
 377   return 1;
 378 }
 379
 380 static int
 381 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
 382 {
 383   td_thrinfo_t ti;
 384   td_err_e err;
 385   struct thread_db *thread_db = current_process ()->private->thread_db;
 386
 387   err = thread_db->td_thr_get_info_p (th_p, &ti);
 388   if (err != TD_OK)
 389     error ("Cannot get thread info: %s", thread_db_err_str (err));
 390
 391   /* Check for zombies.  */
 392   if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
 393     return 0;
 394
 395   if (!maybe_attach_thread (th_p, &ti, (int *) data))
 396     {
 397       /* Terminate iteration early: we might be looking at stale data in
 398          the inferior.  The thread_db_find_new_threads will retry.  */
 399       return 1;
 400     }
 401
 402   return 0;
 403 }
 404
 405 static void
 406 thread_db_find_new_threads (void)
 407 {
 408   td_err_e err;
 409   ptid_t ptid = current_ptid;
 410   struct thread_db *thread_db = current_process ()->private->thread_db;
 411   int loop, iteration;
 412
 413   /* This function is only called when we first initialize thread_db.
 414      First locate the initial thread.  If it is not ready for
 415      debugging yet, then stop.  */
 416   if (find_one_thread (ptid) == 0)
 417     return;
 418
 419   /* Require 4 successive iterations which do not find any new threads.
 420      The 4 is a heuristic: there is an inherent race here, and I have
 421      seen that 2 iterations in a row are not always sufficient to
 422      "capture" all threads.  */
 423   for (loop = 0, iteration = 0; loop < 4; ++loop, ++iteration)
 424     {
 425       int new_thread_count = 0;
 426
 427       /* Iterate over all user-space threads to discover new threads.  */
 428       err = thread_db->td_ta_thr_iter_p (thread_db->thread_agent,
 429                                          find_new_threads_callback,
 430                                          &new_thread_count,
 431                                          TD_THR_ANY_STATE,
 432                                          TD_THR_LOWEST_PRIORITY,
 433                                          TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
 434       if (debug_threads)
 435         fprintf (stderr, "Found %d threads in iteration %d.\n",
 436                  new_thread_count, iteration);
 437
 438       if (new_thread_count != 0)
 439         {
 440           /* Found new threads.  Restart iteration from beginning.  */
 441           loop = -1;
 442         }
 443     }
 444   if (err != TD_OK)
 445     error ("Cannot find new threads: %s", thread_db_err_str (err));
 446 }
 447
 448 /* Cache all future symbols that thread_db might request.  We can not
 449    request symbols at arbitrary states in the remote protocol, only
 450    when the client tells us that new symbols are available.  So when
 451    we load the thread library, make sure to check the entire list.  */
 452
 453 static void
 454 thread_db_look_up_symbols (void)
 455 {
 456   struct thread_db *thread_db = current_process ()->private->thread_db;
 457   const char **sym_list;
 458   CORE_ADDR unused;
 459
 460   for (sym_list = thread_db->td_symbol_list_p (); *sym_list; sym_list++)
 461     look_up_one_symbol (*sym_list, &unused, 1);
 462
 463   /* We're not interested in any other libraries loaded after this
 464      point, only in symbols in libpthread.so.  */
 465   thread_db->all_symbols_looked_up = 1;
 466 }
 467
 468 int
 469 thread_db_look_up_one_symbol (const char *name, CORE_ADDR *addrp)
 470 {
 471   struct thread_db *thread_db = current_process ()->private->thread_db;
 472   int may_ask_gdb = !thread_db->all_symbols_looked_up;
 473
 474   /* If we've passed the call to thread_db_look_up_symbols, then
 475      anything not in the cache must not exist; we're not interested
 476      in any libraries loaded after that point, only in symbols in
 477      libpthread.so.  It might not be an appropriate time to look
 478      up a symbol, e.g. while we're trying to fetch registers.  */
 479   return look_up_one_symbol (name, addrp, may_ask_gdb);
 480 }
 481
 482 int
 483 thread_db_get_tls_address (struct thread_info *thread, CORE_ADDR offset,
 484                            CORE_ADDR load_module, CORE_ADDR *address)
 485 {
 486   psaddr_t addr;
 487   td_err_e err;
 488   struct lwp_info *lwp;
 489   struct thread_info *saved_inferior;
 490   struct process_info *proc;
 491   struct thread_db *thread_db;
 492
 493   proc = get_thread_process (thread);
 494   thread_db = proc->private->thread_db;
 495
 496   /* If the thread layer is not (yet) initialized, fail.  */
 497   if (!thread_db->all_symbols_looked_up)
 498     return TD_ERR;
 499
 500   if (thread_db->td_thr_tls_get_addr_p == NULL)
 501     return -1;
 502
 503   lwp = get_thread_lwp (thread);
 504   if (!lwp->thread_known)
 505     find_one_thread (lwp->head.id);
 506   if (!lwp->thread_known)
 507     return TD_NOTHR;
 508
 509   saved_inferior = current_inferior;
 510   current_inferior = thread;
 511   /* Note the cast through uintptr_t: this interface only works if
 512      a target address fits in a psaddr_t, which is a host pointer.
 513      So a 32-bit debugger can not access 64-bit TLS through this.  */
 514   err = thread_db->td_thr_tls_get_addr_p (&lwp->th,
 515                                           (psaddr_t) (uintptr_t) load_module,
 516                                           offset, &addr);
 517   current_inferior = saved_inferior;
 518   if (err == TD_OK)
 519     {
 520       *address = (CORE_ADDR) (uintptr_t) addr;
 521       return 0;
 522     }
 523   else
 524     return err;
 525 }
 526
 527 #ifdef USE_LIBTHREAD_DB_DIRECTLY
 528
 529 static int
 530 thread_db_load_search (void)
 531 {
 532   td_err_e err;
 533   struct thread_db *tdb;
 534   struct process_info *proc = current_process ();
 535
 536   if (proc->private->thread_db != NULL)
 537     fatal ("unexpected: proc->private->thread_db != NULL");
 538
 539   tdb = xcalloc (1, sizeof (*tdb));
 540   proc->private->thread_db = tdb;
 541
 542   tdb->td_ta_new_p = &td_ta_new;
 543
 544   /* Attempt to open a connection to the thread library.  */
 545   err = tdb->td_ta_new_p (&tdb->proc_handle, &tdb->thread_agent);
 546   if (err != TD_OK)
 547     {
 548       if (debug_threads)
 549         fprintf (stderr, "td_ta_new(): %s\n", thread_db_err_str (err));
 550       free (tdb);
 551       proc->private->thread_db = NULL;
 552       return 0;
 553     }
 554
 555   tdb->td_ta_map_lwp2thr_p = &td_ta_map_lwp2thr;
 556   tdb->td_thr_get_info_p = &td_thr_get_info;
 557   tdb->td_ta_thr_iter_p = &td_ta_thr_iter;
 558   tdb->td_symbol_list_p = &td_symbol_list;
 559
 560   /* This is required only when thread_db_use_events is on.  */
 561   tdb->td_thr_event_enable_p = &td_thr_event_enable;
 562
 563   /* These are not essential.  */
 564   tdb->td_ta_event_addr_p = &td_ta_event_addr;
 565   tdb->td_ta_set_event_p = &td_ta_set_event;
 566   tdb->td_ta_event_getmsg_p = &td_ta_event_getmsg;
 567   tdb->td_thr_tls_get_addr_p = &td_thr_tls_get_addr;
 568
 569   return 1;
 570 }
 571
 572 #else
 573
 574 static int
 575 try_thread_db_load_1 (void *handle)
 576 {
 577   td_err_e err;
 578   struct thread_db *tdb;
 579   struct process_info *proc = current_process ();
 580
 581   if (proc->private->thread_db != NULL)
 582     fatal ("unexpected: proc->private->thread_db != NULL");
 583
 584   tdb = xcalloc (1, sizeof (*tdb));
 585   proc->private->thread_db = tdb;
 586
 587   tdb->handle = handle;
 588
 589   /* Initialize pointers to the dynamic library functions we will use.
 590      Essential functions first.  */
 591
 592 #define CHK(required, a)                                        \
 593   do                                                            \
 594     {                                                           \
 595       if ((a) == NULL)                                          \
 596         {                                                       \
 597           if (debug_threads)                                    \
 598             fprintf (stderr, "dlsym: %s\n", dlerror ());        \
 599           if (required)                                         \
 600             {                                                   \
 601               free (tdb);                                       \
 602               proc->private->thread_db = NULL;                  \
 603               return 0;                                         \
 604             }                                                   \
 605         }                                                       \
 606     }                                                           \
 607   while (0)
 608
 609   CHK (1, tdb->td_ta_new_p = dlsym (handle, "td_ta_new"));
 610
 611   /* Attempt to open a connection to the thread library.  */
 612   err = tdb->td_ta_new_p (&tdb->proc_handle, &tdb->thread_agent);
 613   if (err != TD_OK)
 614     {
 615       if (debug_threads)
 616         fprintf (stderr, "td_ta_new(): %s\n", thread_db_err_str (err));
 617       free (tdb);
 618       proc->private->thread_db = NULL;
 619       return 0;
 620     }
 621
 622   CHK (1, tdb->td_ta_map_lwp2thr_p = dlsym (handle, "td_ta_map_lwp2thr"));
 623   CHK (1, tdb->td_thr_get_info_p = dlsym (handle, "td_thr_get_info"));
 624   CHK (1, tdb->td_ta_thr_iter_p = dlsym (handle, "td_ta_thr_iter"));
 625   CHK (1, tdb->td_symbol_list_p = dlsym (handle, "td_symbol_list"));
 626
 627   /* This is required only when thread_db_use_events is on.  */
 628   CHK (thread_db_use_events,
 629        tdb->td_thr_event_enable_p = dlsym (handle, "td_thr_event_enable"));
 630
 631   /* These are not essential.  */
 632   CHK (0, tdb->td_ta_event_addr_p = dlsym (handle, "td_ta_event_addr"));
 633   CHK (0, tdb->td_ta_set_event_p = dlsym (handle, "td_ta_set_event"));
 634   CHK (0, tdb->td_ta_event_getmsg_p = dlsym (handle, "td_ta_event_getmsg"));
 635   CHK (0, tdb->td_thr_tls_get_addr_p = dlsym (handle, "td_thr_tls_get_addr"));
 636
 637 #undef CHK
 638
 639   return 1;
 640 }
 641
 642 #ifdef HAVE_DLADDR
 643
 644 /* Lookup a library in which given symbol resides.
 645    Note: this is looking in the GDBSERVER process, not in the inferior.
 646    Returns library name, or NULL.  */
 647
 648 static const char *
 649 dladdr_to_soname (const void *addr)
 650 {
 651   Dl_info info;
 652
 653   if (dladdr (addr, &info) != 0)
 654     return info.dli_fname;
 655   return NULL;
 656 }
 657
 658 #endif
 659
 660 static int
 661 try_thread_db_load (const char *library)
 662 {
 663   void *handle;
 664
 665   if (debug_threads)
 666     fprintf (stderr, "Trying host libthread_db library: %s.\n",
 667              library);
 668   handle = dlopen (library, RTLD_NOW);
 669   if (handle == NULL)
 670     {
 671       if (debug_threads)
 672         fprintf (stderr, "dlopen failed: %s.\n", dlerror ());
 673       return 0;
 674     }
 675
 676 #ifdef HAVE_DLADDR
 677   if (debug_threads && strchr (library, '/') == NULL)
 678     {
 679       void *td_init;
 680
 681       td_init = dlsym (handle, "td_init");
 682       if (td_init != NULL)
 683         {
 684           const char *const libpath = dladdr_to_soname (td_init);
 685
 686           if (libpath != NULL)
 687             fprintf (stderr, "Host %s resolved to: %s.\n",
 688                      library, libpath);
 689         }
 690     }
 691 #endif
 692
 693   if (try_thread_db_load_1 (handle))
 694     return 1;
 695
 696   /* This library "refused" to work on current inferior.  */
 697   dlclose (handle);
 698   return 0;
 699 }
 700
 701 /* Handle $sdir in libthread-db-search-path.
 702    Look for libthread_db in the system dirs, or wherever a plain
 703    dlopen(file_without_path) will look.
 704    The result is true for success.  */
 705
 706 static int
 707 try_thread_db_load_from_sdir (void)
 708 {
 709   return try_thread_db_load (LIBTHREAD_DB_SO);
 710 }
 711
 712 /* Try to load libthread_db from directory DIR of length DIR_LEN.
 713    The result is true for success.  */
 714
 715 static int
 716 try_thread_db_load_from_dir (const char *dir, size_t dir_len)
 717 {
 718   char path[PATH_MAX];
 719
 720   if (dir_len + 1 + strlen (LIBTHREAD_DB_SO) + 1 > sizeof (path))
 721     {
 722       char *cp = xmalloc (dir_len + 1);
 723
 724       memcpy (cp, dir, dir_len);
 725       cp[dir_len] = '\0';
 726       warning (_("libthread-db-search-path component too long,"
 727                  " ignored: %s."), cp);
 728       free (cp);
 729       return 0;
 730     }
 731
 732   memcpy (path, dir, dir_len);
 733   path[dir_len] = '/';
 734   strcpy (path + dir_len + 1, LIBTHREAD_DB_SO);
 735   return try_thread_db_load (path);
 736 }
 737
 738 /* Search libthread_db_search_path for libthread_db which "agrees"
 739    to work on current inferior.
 740    The result is true for success.  */
 741
 742 static int
 743 thread_db_load_search (void)
 744 {
 745   VEC (char_ptr) *dir_vec;
 746   char *this_dir;
 747   int i, rc = 0;
 748
 749   if (libthread_db_search_path == NULL)
 750     libthread_db_search_path = xstrdup (LIBTHREAD_DB_SEARCH_PATH);
 751
 752   dir_vec = dirnames_to_char_ptr_vec (libthread_db_search_path);
 753
 754   for (i = 0; VEC_iterate (char_ptr, dir_vec, i, this_dir); ++i)
 755     {
 756       const int pdir_len = sizeof ("$pdir") - 1;
 757       size_t this_dir_len;
 758
 759       this_dir_len = strlen (this_dir);
 760
 761       if (strncmp (this_dir, "$pdir", pdir_len) == 0
 762           && (this_dir[pdir_len] == '\0'
 763               || this_dir[pdir_len] == '/'))
 764         {
 765           /* We don't maintain a list of loaded libraries so we don't know
 766              where libpthread lives.  We *could* fetch the info, but we don't
 767              do that yet.  Ignore it.  */
 768         }
 769       else if (strcmp (this_dir, "$sdir") == 0)
 770         {
 771           if (try_thread_db_load_from_sdir ())
 772             {
 773               rc = 1;
 774               break;
 775             }
 776         }
 777       else
 778         {
 779           if (try_thread_db_load_from_dir (this_dir, this_dir_len))
 780             {
 781               rc = 1;
 782               break;
 783             }
 784         }
 785     }
 786
 787   free_char_ptr_vec (dir_vec);
 788   if (debug_threads)
 789     fprintf (stderr, "thread_db_load_search returning %d\n", rc);
 790   return rc;
 791 }
 792
 793 #endif  /* USE_LIBTHREAD_DB_DIRECTLY */
 794
 795 int
 796 thread_db_init (int use_events)
 797 {
 798   struct process_info *proc = current_process ();
 799
 800   /* FIXME drow/2004-10-16: This is the "overall process ID", which
 801      GNU/Linux calls tgid, "thread group ID".  When we support
 802      attaching to threads, the original thread may not be the correct
 803      thread.  We would have to get the process ID from /proc for NPTL.
 804      For LinuxThreads we could do something similar: follow the chain
 805      of parent processes until we find the highest one we're attached
 806      to, and use its tgid.
 807
 808      This isn't the only place in gdbserver that assumes that the first
 809      process in the list is the thread group leader.  */
 810
 811   thread_db_use_events = use_events;
 812
 813   if (thread_db_load_search ())
 814     {
 815       if (use_events && thread_db_enable_reporting () == 0)
 816         {
 817           /* Keep trying; maybe event reporting will work later.  */
 818           thread_db_mourn (proc);
 819           return 0;
 820         }
 821       thread_db_find_new_threads ();
 822       thread_db_look_up_symbols ();
 823       return 1;
 824     }
 825
 826   return 0;
 827 }
 828
 829 static int
 830 any_thread_of (struct inferior_list_entry *entry, void *args)
 831 {
 832   int *pid_p = args;
 833
 834   if (ptid_get_pid (entry->id) == *pid_p)
 835     return 1;
 836
 837   return 0;
 838 }
 839
 840 static void
 841 switch_to_process (struct process_info *proc)
 842 {
 843   int pid = pid_of (proc);
 844
 845   current_inferior =
 846     (struct thread_info *) find_inferior (&all_threads,
 847                                           any_thread_of, &pid);
 848 }
 849
 850 /* Disconnect from libthread_db and free resources.  */
 851
 852 static void
 853 disable_thread_event_reporting (struct process_info *proc)
 854 {
 855   struct thread_db *thread_db = proc->private->thread_db;
 856   if (thread_db)
 857     {
 858       td_err_e (*td_ta_clear_event_p) (const td_thragent_t *ta,
 859                                        td_thr_events_t *event);
 860
 861 #ifndef USE_LIBTHREAD_DB_DIRECTLY
 862       td_ta_clear_event_p = dlsym (thread_db->handle, "td_ta_clear_event");
 863 #else
 864       td_ta_clear_event_p = &td_ta_clear_event;
 865 #endif
 866
 867       if (td_ta_clear_event_p != NULL)
 868         {
 869           struct thread_info *saved_inferior = current_inferior;
 870           td_thr_events_t events;
 871
 872           switch_to_process (proc);
 873
 874           /* Set the process wide mask saying we aren't interested
 875              in any events anymore.  */
 876           td_event_fillset (&events);
 877           (*td_ta_clear_event_p) (thread_db->thread_agent, &events);
 878
 879           current_inferior = saved_inferior;
 880         }
 881     }
 882 }
 883
 884 static void
 885 remove_thread_event_breakpoints (struct process_info *proc)
 886 {
 887   struct thread_db *thread_db = proc->private->thread_db;
 888
 889   if (thread_db->td_create_bp != NULL)
 890     {
 891       struct thread_info *saved_inferior = current_inferior;
 892
 893       switch_to_process (proc);
 894
 895       delete_breakpoint (thread_db->td_create_bp);
 896       thread_db->td_create_bp = NULL;
 897
 898       current_inferior = saved_inferior;
 899     }
 900 }
 901
 902 void
 903 thread_db_detach (struct process_info *proc)
 904 {
 905   struct thread_db *thread_db = proc->private->thread_db;
 906
 907   if (thread_db)
 908     {
 909       disable_thread_event_reporting (proc);
 910       remove_thread_event_breakpoints (proc);
 911     }
 912 }
 913
 914 /* Disconnect from libthread_db and free resources.  */
 915
 916 void
 917 thread_db_mourn (struct process_info *proc)
 918 {
 919   struct thread_db *thread_db = proc->private->thread_db;
 920   if (thread_db)
 921     {
 922       td_err_e (*td_ta_delete_p) (td_thragent_t *);
 923
 924 #ifndef USE_LIBTHREAD_DB_DIRECTLY
 925       td_ta_delete_p = dlsym (thread_db->handle, "td_ta_delete");
 926 #else
 927       td_ta_delete_p = &td_ta_delete;
 928 #endif
 929
 930       if (td_ta_delete_p != NULL)
 931         (*td_ta_delete_p) (thread_db->thread_agent);
 932
 933 #ifndef USE_LIBTHREAD_DB_DIRECTLY
 934       dlclose (thread_db->handle);
 935 #endif  /* USE_LIBTHREAD_DB_DIRECTLY  */
 936
 937       free (thread_db);
 938       proc->private->thread_db = NULL;
 939     }
 940 }
 941
 942 /* Handle "set libthread-db-search-path" monitor command and return 1.
 943    For any other command, return 0.  */
 944
 945 int
 946 thread_db_handle_monitor_command (char *mon)
 947 {
 948   const char *cmd = "set libthread-db-search-path";
 949   size_t cmd_len = strlen (cmd);
 950
 951   if (strncmp (mon, cmd, cmd_len) == 0
 952       && (mon[cmd_len] == '\0'
 953           || mon[cmd_len] == ' '))
 954     {
 955       const char *cp = mon + cmd_len;
 956
 957       if (libthread_db_search_path != NULL)
 958         free (libthread_db_search_path);
 959
 960       /* Skip leading space (if any).  */
 961       while (isspace (*cp))
 962         ++cp;
 963
 964       if (*cp == '\0')
 965         cp = LIBTHREAD_DB_SEARCH_PATH;
 966       libthread_db_search_path = xstrdup (cp);
 967
 968       monitor_output ("libthread-db-search-path set to `");
 969       monitor_output (libthread_db_search_path);
 970       monitor_output ("'\n");
 971       return 1;
 972     }
 973
 974   /* Tell server.c to perform default processing.  */
 975   return 0;
 976 }