gdb/gdbserver/thread-db.c

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