gdb/gdbserver/thread-db.c

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