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