1/* libthread_db assisted debugging support, generic parts. 2 3 Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 4 2010, 2011 Free Software Foundation, Inc. 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 "defs.h" 22 23#include "gdb_assert.h" 24#include <dlfcn.h> 25#include "gdb_proc_service.h" 26#include "gdb_thread_db.h" 27 28#include "bfd.h" 29#include "command.h" 30#include "exceptions.h" 31#include "gdbcmd.h" 32#include "gdbthread.h" 33#include "inferior.h" 34#include "symfile.h" 35#include "objfiles.h" 36#include "target.h" 37#include "regcache.h" 38#include "solib.h" 39#include "solib-svr4.h" 40#include "gdbcore.h" 41#include "observer.h" 42#include "linux-nat.h" 43 44#include <signal.h> 45 46#ifdef HAVE_GNU_LIBC_VERSION_H 47#include <gnu/libc-version.h> 48#endif 49 50/* GNU/Linux libthread_db support. 51 52 libthread_db is a library, provided along with libpthread.so, which 53 exposes the internals of the thread library to a debugger. It 54 allows GDB to find existing threads, new threads as they are 55 created, thread IDs (usually, the result of pthread_self), and 56 thread-local variables. 57 58 The libthread_db interface originates on Solaris, where it is 59 both more powerful and more complicated. This implementation 60 only works for LinuxThreads and NPTL, the two glibc threading 61 libraries. It assumes that each thread is permanently assigned 62 to a single light-weight process (LWP). 63 64 libthread_db-specific information is stored in the "private" field 65 of struct thread_info. When the field is NULL we do not yet have 66 information about the new thread; this could be temporary (created, 67 but the thread library's data structures do not reflect it yet) 68 or permanent (created using clone instead of pthread_create). 69 70 Process IDs managed by linux-thread-db.c match those used by 71 linux-nat.c: a common PID for all processes, an LWP ID for each 72 thread, and no TID. We save the TID in private. Keeping it out 73 of the ptid_t prevents thread IDs changing when libpthread is 74 loaded or unloaded. */ 75 76static char *libthread_db_search_path; 77 78/* If non-zero, print details of libthread_db processing. */ 79 80static int libthread_db_debug; 81 82static void 83show_libthread_db_debug (struct ui_file *file, int from_tty, 84 struct cmd_list_element *c, const char *value) 85{ 86 fprintf_filtered (file, _("libthread-db debugging is %s.\n"), value); 87} 88 89 90/* If we're running on GNU/Linux, we must explicitly attach to any new 91 threads. */ 92 93/* This module's target vector. */ 94static struct target_ops thread_db_ops; 95 96/* Non-zero if we have determined the signals used by the threads 97 library. */ 98static int thread_signals; 99static sigset_t thread_stop_set; 100static sigset_t thread_print_set; 101 102struct thread_db_info 103{ 104 struct thread_db_info *next; 105 106 /* Process id this object refers to. */ 107 int pid; 108 109 /* Handle from dlopen for libthread_db.so. */ 110 void *handle; 111 112 /* Structure that identifies the child process for the 113 <proc_service.h> interface. */ 114 struct ps_prochandle proc_handle; 115 116 /* Connection to the libthread_db library. */ 117 td_thragent_t *thread_agent; 118 119 /* True if we need to apply the workaround for glibc/BZ5983. When 120 we catch a PTRACE_O_TRACEFORK, and go query the child's thread 121 list, nptl_db returns the parent's threads in addition to the new 122 (single) child thread. If this flag is set, we do extra work to 123 be able to ignore such stale entries. */ 124 int need_stale_parent_threads_check; 125 126 /* Location of the thread creation event breakpoint. The code at 127 this location in the child process will be called by the pthread 128 library whenever a new thread is created. By setting a special 129 breakpoint at this location, GDB can detect when a new thread is 130 created. We obtain this location via the td_ta_event_addr 131 call. */ 132 CORE_ADDR td_create_bp_addr; 133 134 /* Location of the thread death event breakpoint. */ 135 CORE_ADDR td_death_bp_addr; 136 137 /* Pointers to the libthread_db functions. */ 138 139 td_err_e (*td_init_p) (void); 140 141 td_err_e (*td_ta_new_p) (struct ps_prochandle * ps, 142 td_thragent_t **ta); 143 td_err_e (*td_ta_map_id2thr_p) (const td_thragent_t *ta, thread_t pt, 144 td_thrhandle_t *__th); 145 td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta, 146 lwpid_t lwpid, td_thrhandle_t *th); 147 td_err_e (*td_ta_thr_iter_p) (const td_thragent_t *ta, 148 td_thr_iter_f *callback, void *cbdata_p, 149 td_thr_state_e state, int ti_pri, 150 sigset_t *ti_sigmask_p, 151 unsigned int ti_user_flags); 152 td_err_e (*td_ta_event_addr_p) (const td_thragent_t *ta, 153 td_event_e event, td_notify_t *ptr); 154 td_err_e (*td_ta_set_event_p) (const td_thragent_t *ta, 155 td_thr_events_t *event); 156 td_err_e (*td_ta_clear_event_p) (const td_thragent_t *ta, 157 td_thr_events_t *event); 158 td_err_e (*td_ta_event_getmsg_p) (const td_thragent_t *ta, 159 td_event_msg_t *msg); 160 161 td_err_e (*td_thr_validate_p) (const td_thrhandle_t *th); 162 td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th, 163 td_thrinfo_t *infop); 164 td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th, 165 int event); 166 167 td_err_e (*td_thr_tls_get_addr_p) (const td_thrhandle_t *th, 168 psaddr_t map_address, 169 size_t offset, psaddr_t *address); 170}; 171 172/* List of known processes using thread_db, and the required 173 bookkeeping. */ 174struct thread_db_info *thread_db_list; 175 176static void thread_db_find_new_threads_1 (ptid_t ptid); 177static void thread_db_find_new_threads_2 (ptid_t ptid, int until_no_new); 178 179/* Add the current inferior to the list of processes using libpthread. 180 Return a pointer to the newly allocated object that was added to 181 THREAD_DB_LIST. HANDLE is the handle returned by dlopen'ing 182 LIBTHREAD_DB_SO. */ 183 184static struct thread_db_info * 185add_thread_db_info (void *handle) 186{ 187 struct thread_db_info *info; 188 189 info = xcalloc (1, sizeof (*info)); 190 info->pid = ptid_get_pid (inferior_ptid); 191 info->handle = handle; 192 193 /* The workaround works by reading from /proc/pid/status, so it is 194 disabled for core files. */ 195 if (target_has_execution) 196 info->need_stale_parent_threads_check = 1; 197 198 info->next = thread_db_list; 199 thread_db_list = info; 200 201 return info; 202} 203 204/* Return the thread_db_info object representing the bookkeeping 205 related to process PID, if any; NULL otherwise. */ 206 207static struct thread_db_info * 208get_thread_db_info (int pid) 209{ 210 struct thread_db_info *info; 211 212 for (info = thread_db_list; info; info = info->next) 213 if (pid == info->pid) 214 return info; 215 216 return NULL; 217} 218 219/* When PID has exited or has been detached, we no longer want to keep 220 track of it as using libpthread. Call this function to discard 221 thread_db related info related to PID. Note that this closes 222 LIBTHREAD_DB_SO's dlopen'ed handle. */ 223 224static void 225delete_thread_db_info (int pid) 226{ 227 struct thread_db_info *info, *info_prev; 228 229 info_prev = NULL; 230 231 for (info = thread_db_list; info; info_prev = info, info = info->next) 232 if (pid == info->pid) 233 break; 234 235 if (info == NULL) 236 return; 237 238 if (info->handle != NULL) 239 dlclose (info->handle); 240 241 if (info_prev) 242 info_prev->next = info->next; 243 else 244 thread_db_list = info->next; 245 246 xfree (info); 247} 248 249/* Prototypes for local functions. */ 250static int attach_thread (ptid_t ptid, const td_thrhandle_t *th_p, 251 const td_thrinfo_t *ti_p); 252static void detach_thread (ptid_t ptid); 253 254 255/* Use "struct private_thread_info" to cache thread state. This is 256 a substantial optimization. */ 257 258struct private_thread_info 259{ 260 /* Flag set when we see a TD_DEATH event for this thread. */ 261 unsigned int dying:1; 262 263 /* Cached thread state. */ 264 td_thrhandle_t th; 265 thread_t tid; 266}; 267 268 269static char * 270thread_db_err_str (td_err_e err) 271{ 272 static char buf[64]; 273 274 switch (err) 275 { 276 case TD_OK: 277 return "generic 'call succeeded'"; 278 case TD_ERR: 279 return "generic error"; 280 case TD_NOTHR: 281 return "no thread to satisfy query"; 282 case TD_NOSV: 283 return "no sync handle to satisfy query"; 284 case TD_NOLWP: 285 return "no LWP to satisfy query"; 286 case TD_BADPH: 287 return "invalid process handle"; 288 case TD_BADTH: 289 return "invalid thread handle"; 290 case TD_BADSH: 291 return "invalid synchronization handle"; 292 case TD_BADTA: 293 return "invalid thread agent"; 294 case TD_BADKEY: 295 return "invalid key"; 296 case TD_NOMSG: 297 return "no event message for getmsg"; 298 case TD_NOFPREGS: 299 return "FPU register set not available"; 300 case TD_NOLIBTHREAD: 301 return "application not linked with libthread"; 302 case TD_NOEVENT: 303 return "requested event is not supported"; 304 case TD_NOCAPAB: 305 return "capability not available"; 306 case TD_DBERR: 307 return "debugger service failed"; 308 case TD_NOAPLIC: 309 return "operation not applicable to"; 310 case TD_NOTSD: 311 return "no thread-specific data for this thread"; 312 case TD_MALLOC: 313 return "malloc failed"; 314 case TD_PARTIALREG: 315 return "only part of register set was written/read"; 316 case TD_NOXREGS: 317 return "X register set not available for this thread"; 318#ifdef THREAD_DB_HAS_TD_NOTALLOC 319 case TD_NOTALLOC: 320 return "thread has not yet allocated TLS for given module"; 321#endif 322#ifdef THREAD_DB_HAS_TD_VERSION 323 case TD_VERSION: 324 return "versions of libpthread and libthread_db do not match"; 325#endif 326#ifdef THREAD_DB_HAS_TD_NOTLS 327 case TD_NOTLS: 328 return "there is no TLS segment in the given module"; 329#endif 330 default: 331 snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err); 332 return buf; 333 } 334} 335 336/* Return 1 if any threads have been registered. There may be none if 337 the threading library is not fully initialized yet. */ 338 339static int 340have_threads_callback (struct thread_info *thread, void *args) 341{ 342 int pid = * (int *) args; 343 344 if (ptid_get_pid (thread->ptid) != pid) 345 return 0; 346 347 return thread->private != NULL; 348} 349 350static int 351have_threads (ptid_t ptid) 352{ 353 int pid = ptid_get_pid (ptid); 354 355 return iterate_over_threads (have_threads_callback, &pid) != NULL; 356} 357 358struct thread_get_info_inout 359{ 360 struct thread_info *thread_info; 361 struct thread_db_info *thread_db_info; 362}; 363 364/* A callback function for td_ta_thr_iter, which we use to map all 365 threads to LWPs. 366 367 THP is a handle to the current thread; if INFOP is not NULL, the 368 struct thread_info associated with this thread is returned in 369 *INFOP. 370 371 If the thread is a zombie, TD_THR_ZOMBIE is returned. Otherwise, 372 zero is returned to indicate success. */ 373 374static int 375thread_get_info_callback (const td_thrhandle_t *thp, void *argp) 376{ 377 td_thrinfo_t ti; 378 td_err_e err; 379 ptid_t thread_ptid; 380 struct thread_get_info_inout *inout; 381 struct thread_db_info *info; 382 383 inout = argp; 384 info = inout->thread_db_info; 385 386 err = info->td_thr_get_info_p (thp, &ti); 387 if (err != TD_OK) 388 error (_("thread_get_info_callback: cannot get thread info: %s"), 389 thread_db_err_str (err)); 390 391 /* Fill the cache. */ 392 thread_ptid = ptid_build (info->pid, ti.ti_lid, 0); 393 inout->thread_info = find_thread_ptid (thread_ptid); 394 395 /* In the case of a zombie thread, don't continue. We don't want to 396 attach to it thinking it is a new thread. */ 397 if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE) 398 return TD_THR_ZOMBIE; 399 400 if (inout->thread_info == NULL) 401 { 402 /* New thread. Attach to it now (why wait?). */ 403 if (!have_threads (thread_ptid)) 404 thread_db_find_new_threads_1 (thread_ptid); 405 else 406 attach_thread (thread_ptid, thp, &ti); 407 inout->thread_info = find_thread_ptid (thread_ptid); 408 gdb_assert (inout->thread_info != NULL); 409 } 410 411 return 0; 412} 413 414/* Convert between user-level thread ids and LWP ids. */ 415 416static ptid_t 417thread_from_lwp (ptid_t ptid) 418{ 419 td_thrhandle_t th; 420 td_err_e err; 421 struct thread_db_info *info; 422 struct thread_get_info_inout io = {0}; 423 424 /* This ptid comes from linux-nat.c, which should always fill in the 425 LWP. */ 426 gdb_assert (GET_LWP (ptid) != 0); 427 428 info = get_thread_db_info (GET_PID (ptid)); 429 430 /* Access an lwp we know is stopped. */ 431 info->proc_handle.ptid = ptid; 432 err = info->td_ta_map_lwp2thr_p (info->thread_agent, GET_LWP (ptid), &th); 433 if (err != TD_OK) 434 error (_("Cannot find user-level thread for LWP %ld: %s"), 435 GET_LWP (ptid), thread_db_err_str (err)); 436 437 /* Fetch the thread info. If we get back TD_THR_ZOMBIE, then the 438 event thread has already died. If another gdb interface has called 439 thread_alive() previously, the thread won't be found on the thread list 440 anymore. In that case, we don't want to process this ptid anymore 441 to avoid the possibility of later treating it as a newly 442 discovered thread id that we should add to the list. Thus, 443 we return a -1 ptid which is also how the thread list marks a 444 dead thread. */ 445 io.thread_db_info = info; 446 io.thread_info = NULL; 447 if (thread_get_info_callback (&th, &io) == TD_THR_ZOMBIE 448 && io.thread_info == NULL) 449 return minus_one_ptid; 450 451 gdb_assert (ptid_get_tid (ptid) == 0); 452 return ptid; 453} 454 455 456/* Attach to lwp PTID, doing whatever else is required to have this 457 LWP under the debugger's control --- e.g., enabling event 458 reporting. Returns true on success. */ 459int 460thread_db_attach_lwp (ptid_t ptid) 461{ 462 td_thrhandle_t th; 463 td_thrinfo_t ti; 464 td_err_e err; 465 struct thread_db_info *info; 466 467 info = get_thread_db_info (GET_PID (ptid)); 468 469 if (info == NULL) 470 return 0; 471 472 /* This ptid comes from linux-nat.c, which should always fill in the 473 LWP. */ 474 gdb_assert (GET_LWP (ptid) != 0); 475 476 /* Access an lwp we know is stopped. */ 477 info->proc_handle.ptid = ptid; 478 479 /* If we have only looked at the first thread before libpthread was 480 initialized, we may not know its thread ID yet. Make sure we do 481 before we add another thread to the list. */ 482 if (!have_threads (ptid)) 483 thread_db_find_new_threads_1 (ptid); 484 485 err = info->td_ta_map_lwp2thr_p (info->thread_agent, GET_LWP (ptid), &th); 486 if (err != TD_OK) 487 /* Cannot find user-level thread. */ 488 return 0; 489 490 err = info->td_thr_get_info_p (&th, &ti); 491 if (err != TD_OK) 492 { 493 warning (_("Cannot get thread info: %s"), thread_db_err_str (err)); 494 return 0; 495 } 496 497 attach_thread (ptid, &th, &ti); 498 return 1; 499} 500 501static void * 502verbose_dlsym (void *handle, const char *name) 503{ 504 void *sym = dlsym (handle, name); 505 if (sym == NULL) 506 warning (_("Symbol \"%s\" not found in libthread_db: %s"), 507 name, dlerror ()); 508 return sym; 509} 510 511static td_err_e 512enable_thread_event (int event, CORE_ADDR *bp) 513{ 514 td_notify_t notify; 515 td_err_e err; 516 struct thread_db_info *info; 517 518 info = get_thread_db_info (GET_PID (inferior_ptid)); 519 520 /* Access an lwp we know is stopped. */ 521 info->proc_handle.ptid = inferior_ptid; 522 523 /* Get the breakpoint address for thread EVENT. */ 524 err = info->td_ta_event_addr_p (info->thread_agent, event, ¬ify); 525 if (err != TD_OK) 526 return err; 527 528 /* Set up the breakpoint. */ 529 gdb_assert (exec_bfd); 530 (*bp) = (gdbarch_convert_from_func_ptr_addr 531 (target_gdbarch, 532 /* Do proper sign extension for the target. */ 533 (bfd_get_sign_extend_vma (exec_bfd) > 0 534 ? (CORE_ADDR) (intptr_t) notify.u.bptaddr 535 : (CORE_ADDR) (uintptr_t) notify.u.bptaddr), 536 ¤t_target)); 537 create_thread_event_breakpoint (target_gdbarch, *bp); 538 539 return TD_OK; 540} 541 542static void 543enable_thread_event_reporting (void) 544{ 545 td_thr_events_t events; 546 td_err_e err; 547#ifdef HAVE_GNU_LIBC_VERSION_H 548 const char *libc_version; 549 int libc_major, libc_minor; 550#endif 551 struct thread_db_info *info; 552 553 info = get_thread_db_info (GET_PID (inferior_ptid)); 554 555 /* We cannot use the thread event reporting facility if these 556 functions aren't available. */ 557 if (info->td_ta_event_addr_p == NULL 558 || info->td_ta_set_event_p == NULL 559 || info->td_ta_event_getmsg_p == NULL 560 || info->td_thr_event_enable_p == NULL) 561 return; 562 563 /* Set the process wide mask saying which events we're interested in. */ 564 td_event_emptyset (&events); 565 td_event_addset (&events, TD_CREATE); 566 567#ifdef HAVE_GNU_LIBC_VERSION_H 568 /* The event reporting facility is broken for TD_DEATH events in 569 glibc 2.1.3, so don't enable it if we have glibc but a lower 570 version. */ 571 libc_version = gnu_get_libc_version (); 572 if (sscanf (libc_version, "%d.%d", &libc_major, &libc_minor) == 2 573 && (libc_major > 2 || (libc_major == 2 && libc_minor > 1))) 574#endif 575 td_event_addset (&events, TD_DEATH); 576 577 err = info->td_ta_set_event_p (info->thread_agent, &events); 578 if (err != TD_OK) 579 { 580 warning (_("Unable to set global thread event mask: %s"), 581 thread_db_err_str (err)); 582 return; 583 } 584 585 /* Delete previous thread event breakpoints, if any. */ 586 remove_thread_event_breakpoints (); 587 info->td_create_bp_addr = 0; 588 info->td_death_bp_addr = 0; 589 590 /* Set up the thread creation event. */ 591 err = enable_thread_event (TD_CREATE, &info->td_create_bp_addr); 592 if (err != TD_OK) 593 { 594 warning (_("Unable to get location for thread creation breakpoint: %s"), 595 thread_db_err_str (err)); 596 return; 597 } 598 599 /* Set up the thread death event. */ 600 err = enable_thread_event (TD_DEATH, &info->td_death_bp_addr); 601 if (err != TD_OK) 602 { 603 warning (_("Unable to get location for thread death breakpoint: %s"), 604 thread_db_err_str (err)); 605 return; 606 } 607} 608 609/* Same as thread_db_find_new_threads_1, but silently ignore errors. */ 610 611static void 612thread_db_find_new_threads_silently (ptid_t ptid) 613{ 614 volatile struct gdb_exception except; 615 616 TRY_CATCH (except, RETURN_MASK_ERROR) 617 { 618 thread_db_find_new_threads_2 (ptid, 1); 619 } 620 621 if (except.reason < 0 && libthread_db_debug) 622 { 623 exception_fprintf (gdb_stderr, except, 624 "Warning: thread_db_find_new_threads_silently: "); 625 } 626} 627 628/* Lookup a library in which given symbol resides. 629 Note: this is looking in GDB process, not in the inferior. 630 Returns library name, or NULL. */ 631 632static const char * 633dladdr_to_soname (const void *addr) 634{ 635 Dl_info info; 636 637 if (dladdr (addr, &info) != 0) 638 return info.dli_fname; 639 return NULL; 640} 641 642/* Attempt to initialize dlopen()ed libthread_db, described by HANDLE. 643 Return 1 on success. 644 Failure could happen if libthread_db does not have symbols we expect, 645 or when it refuses to work with the current inferior (e.g. due to 646 version mismatch between libthread_db and libpthread). */ 647 648static int 649try_thread_db_load_1 (struct thread_db_info *info) 650{ 651 td_err_e err; 652 653 /* Initialize pointers to the dynamic library functions we will use. 654 Essential functions first. */ 655 656 info->td_init_p = verbose_dlsym (info->handle, "td_init"); 657 if (info->td_init_p == NULL) 658 return 0; 659 660 err = info->td_init_p (); 661 if (err != TD_OK) 662 { 663 warning (_("Cannot initialize libthread_db: %s"), 664 thread_db_err_str (err)); 665 return 0; 666 } 667 668 info->td_ta_new_p = verbose_dlsym (info->handle, "td_ta_new"); 669 if (info->td_ta_new_p == NULL) 670 return 0; 671 672 /* Initialize the structure that identifies the child process. */ 673 info->proc_handle.ptid = inferior_ptid; 674 675 /* Now attempt to open a connection to the thread library. */ 676 err = info->td_ta_new_p (&info->proc_handle, &info->thread_agent); 677 if (err != TD_OK) 678 { 679 if (libthread_db_debug) 680 printf_unfiltered (_("td_ta_new failed: %s\n"), 681 thread_db_err_str (err)); 682 else 683 switch (err) 684 { 685 case TD_NOLIBTHREAD: 686#ifdef THREAD_DB_HAS_TD_VERSION 687 case TD_VERSION: 688#endif 689 /* The errors above are not unexpected and silently ignored: 690 they just mean we haven't found correct version of 691 libthread_db yet. */ 692 break; 693 default: 694 warning (_("td_ta_new failed: %s"), thread_db_err_str (err)); 695 } 696 return 0; 697 } 698 699 info->td_ta_map_id2thr_p = verbose_dlsym (info->handle, "td_ta_map_id2thr"); 700 if (info->td_ta_map_id2thr_p == NULL) 701 return 0; 702 703 info->td_ta_map_lwp2thr_p = verbose_dlsym (info->handle, 704 "td_ta_map_lwp2thr"); 705 if (info->td_ta_map_lwp2thr_p == NULL) 706 return 0; 707 708 info->td_ta_thr_iter_p = verbose_dlsym (info->handle, "td_ta_thr_iter"); 709 if (info->td_ta_thr_iter_p == NULL) 710 return 0; 711 712 info->td_thr_validate_p = verbose_dlsym (info->handle, "td_thr_validate"); 713 if (info->td_thr_validate_p == NULL) 714 return 0; 715 716 info->td_thr_get_info_p = verbose_dlsym (info->handle, "td_thr_get_info"); 717 if (info->td_thr_get_info_p == NULL) 718 return 0; 719 720 /* These are not essential. */ 721 info->td_ta_event_addr_p = dlsym (info->handle, "td_ta_event_addr"); 722 info->td_ta_set_event_p = dlsym (info->handle, "td_ta_set_event"); 723 info->td_ta_clear_event_p = dlsym (info->handle, "td_ta_clear_event"); 724 info->td_ta_event_getmsg_p = dlsym (info->handle, "td_ta_event_getmsg"); 725 info->td_thr_event_enable_p = dlsym (info->handle, "td_thr_event_enable"); 726 info->td_thr_tls_get_addr_p = dlsym (info->handle, "td_thr_tls_get_addr"); 727 728 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n")); 729 730 if (libthread_db_debug || *libthread_db_search_path) 731 { 732 const char *library; 733 734 library = dladdr_to_soname (*info->td_ta_new_p); 735 if (library == NULL) 736 library = LIBTHREAD_DB_SO; 737 738 printf_unfiltered (_("Using host libthread_db library \"%s\".\n"), 739 library); 740 } 741 742 /* The thread library was detected. Activate the thread_db target 743 if this is the first process using it. */ 744 if (thread_db_list->next == NULL) 745 push_target (&thread_db_ops); 746 747 /* Enable event reporting, but not when debugging a core file. */ 748 if (target_has_execution) 749 enable_thread_event_reporting (); 750 751 /* There appears to be a bug in glibc-2.3.6: calls to td_thr_get_info fail 752 with TD_ERR for statically linked executables if td_thr_get_info is 753 called before glibc has initialized itself. Silently ignore such 754 errors, and let gdb enumerate threads again later. */ 755 thread_db_find_new_threads_silently (inferior_ptid); 756 757 return 1; 758} 759 760/* Attempt to use LIBRARY as libthread_db. LIBRARY could be absolute, 761 relative, or just LIBTHREAD_DB. */ 762 763static int 764try_thread_db_load (const char *library) 765{ 766 void *handle; 767 struct thread_db_info *info; 768 769 if (libthread_db_debug) 770 printf_unfiltered (_("Trying host libthread_db library: %s.\n"), 771 library); 772 handle = dlopen (library, RTLD_NOW); 773 if (handle == NULL) 774 { 775 if (libthread_db_debug) 776 printf_unfiltered (_("dlopen failed: %s.\n"), dlerror ()); 777 return 0; 778 } 779 780 if (libthread_db_debug && strchr (library, '/') == NULL) 781 { 782 void *td_init; 783 784 td_init = dlsym (handle, "td_init"); 785 if (td_init != NULL) 786 { 787 const char *const libpath = dladdr_to_soname (td_init); 788 789 if (libpath != NULL) 790 printf_unfiltered (_("Host %s resolved to: %s.\n"), 791 library, libpath); 792 } 793 } 794 795 info = add_thread_db_info (handle); 796 797 if (try_thread_db_load_1 (info)) 798 return 1; 799 800 /* This library "refused" to work on current inferior. */ 801 delete_thread_db_info (GET_PID (inferior_ptid)); 802 return 0; 803} 804 805 806/* Search libthread_db_search_path for libthread_db which "agrees" 807 to work on current inferior. */ 808 809static int 810thread_db_load_search (void) 811{ 812 char path[PATH_MAX]; 813 const char *search_path = libthread_db_search_path; 814 int rc = 0; 815 816 while (*search_path) 817 { 818 const char *end = strchr (search_path, ':'); 819 820 if (end) 821 { 822 size_t len = end - search_path; 823 824 if (len + 1 + strlen (LIBTHREAD_DB_SO) + 1 > sizeof (path)) 825 { 826 char *cp = xmalloc (len + 1); 827 828 memcpy (cp, search_path, len); 829 cp[len] = '\0'; 830 warning (_("libthread_db_search_path component too long," 831 " ignored: %s."), cp); 832 xfree (cp); 833 search_path += len + 1; 834 continue; 835 } 836 memcpy (path, search_path, len); 837 path[len] = '\0'; 838 search_path += len + 1; 839 } 840 else 841 { 842 size_t len = strlen (search_path); 843 844 if (len + 1 + strlen (LIBTHREAD_DB_SO) + 1 > sizeof (path)) 845 { 846 warning (_("libthread_db_search_path component too long," 847 " ignored: %s."), search_path); 848 break; 849 } 850 memcpy (path, search_path, len + 1); 851 search_path += len; 852 } 853 strcat (path, "/"); 854 strcat (path, LIBTHREAD_DB_SO); 855 if (try_thread_db_load (path)) 856 { 857 rc = 1; 858 break; 859 } 860 } 861 if (rc == 0) 862 rc = try_thread_db_load (LIBTHREAD_DB_SO); 863 return rc; 864} 865 866/* Attempt to load and initialize libthread_db. 867 Return 1 on success. */ 868 869static int 870thread_db_load (void) 871{ 872 struct objfile *obj; 873 struct thread_db_info *info; 874 875 info = get_thread_db_info (GET_PID (inferior_ptid)); 876 877 if (info != NULL) 878 return 1; 879 880 /* Don't attempt to use thread_db on executables not running 881 yet. */ 882 if (!target_has_registers) 883 return 0; 884 885 /* Don't attempt to use thread_db for remote targets. */ 886 if (!(target_can_run (¤t_target) || core_bfd)) 887 return 0; 888 889 if (thread_db_load_search ()) 890 return 1; 891 892 /* None of the libthread_db's on our search path, not the system default 893 ones worked. If the executable is dynamically linked against 894 libpthread, try loading libthread_db from the same directory. */ 895 896 ALL_OBJFILES (obj) 897 if (libpthread_name_p (obj->name)) 898 { 899 char path[PATH_MAX], *cp; 900 901 gdb_assert (strlen (obj->name) < sizeof (path)); 902 strcpy (path, obj->name); 903 cp = strrchr (path, '/'); 904 905 if (cp == NULL) 906 { 907 warning (_("Expected absolute pathname for libpthread in the" 908 " inferior, but got %s."), path); 909 } 910 else if (cp + 1 + strlen (LIBTHREAD_DB_SO) + 1 > path + sizeof (path)) 911 { 912 warning (_("Unexpected: path to libpthread in the inferior is" 913 " too long: %s"), path); 914 } 915 else 916 { 917 strcpy (cp + 1, LIBTHREAD_DB_SO); 918 if (try_thread_db_load (path)) 919 return 1; 920 } 921 warning (_("Unable to find libthread_db matching inferior's thread" 922 " library, thread debugging will not be available.")); 923 return 0; 924 } 925 /* Either this executable isn't using libpthread at all, or it is 926 statically linked. Since we can't easily distinguish these two cases, 927 no warning is issued. */ 928 return 0; 929} 930 931static void 932disable_thread_event_reporting (struct thread_db_info *info) 933{ 934 if (info->td_ta_clear_event_p != NULL) 935 { 936 td_thr_events_t events; 937 938 /* Set the process wide mask saying we aren't interested in any 939 events anymore. */ 940 td_event_fillset (&events); 941 info->td_ta_clear_event_p (info->thread_agent, &events); 942 } 943 944 info->td_create_bp_addr = 0; 945 info->td_death_bp_addr = 0; 946} 947 948static void 949check_thread_signals (void) 950{ 951 if (!thread_signals) 952 { 953 sigset_t mask; 954 int i; 955 956 lin_thread_get_thread_signals (&mask); 957 sigemptyset (&thread_stop_set); 958 sigemptyset (&thread_print_set); 959 960 for (i = 1; i < NSIG; i++) 961 { 962 if (sigismember (&mask, i)) 963 { 964 if (signal_stop_update (target_signal_from_host (i), 0)) 965 sigaddset (&thread_stop_set, i); 966 if (signal_print_update (target_signal_from_host (i), 0)) 967 sigaddset (&thread_print_set, i); 968 thread_signals = 1; 969 } 970 } 971 } 972} 973 974/* Check whether thread_db is usable. This function is called when 975 an inferior is created (or otherwise acquired, e.g. attached to) 976 and when new shared libraries are loaded into a running process. */ 977 978void 979check_for_thread_db (void) 980{ 981 /* Do nothing if we couldn't load libthread_db.so.1. */ 982 if (!thread_db_load ()) 983 return; 984} 985 986static void 987thread_db_new_objfile (struct objfile *objfile) 988{ 989 /* This observer must always be called with inferior_ptid set 990 correctly. */ 991 992 if (objfile != NULL) 993 check_for_thread_db (); 994} 995 996/* Attach to a new thread. This function is called when we receive a 997 TD_CREATE event or when we iterate over all threads and find one 998 that wasn't already in our list. Returns true on success. */ 999 1000static int 1001attach_thread (ptid_t ptid, const td_thrhandle_t *th_p, 1002 const td_thrinfo_t *ti_p) 1003{ 1004 struct private_thread_info *private; 1005 struct thread_info *tp = NULL; 1006 td_err_e err; 1007 struct thread_db_info *info; 1008 1009 /* If we're being called after a TD_CREATE event, we may already 1010 know about this thread. There are two ways this can happen. We 1011 may have iterated over all threads between the thread creation 1012 and the TD_CREATE event, for instance when the user has issued 1013 the `info threads' command before the SIGTRAP for hitting the 1014 thread creation breakpoint was reported. Alternatively, the 1015 thread may have exited and a new one been created with the same 1016 thread ID. In the first case we don't need to do anything; in 1017 the second case we should discard information about the dead 1018 thread and attach to the new one. */ 1019 if (in_thread_list (ptid)) 1020 { 1021 tp = find_thread_ptid (ptid); 1022 gdb_assert (tp != NULL); 1023 1024 /* If tp->private is NULL, then GDB is already attached to this 1025 thread, but we do not know anything about it. We can learn 1026 about it here. This can only happen if we have some other 1027 way besides libthread_db to notice new threads (i.e. 1028 PTRACE_EVENT_CLONE); assume the same mechanism notices thread 1029 exit, so this can not be a stale thread recreated with the 1030 same ID. */ 1031 if (tp->private != NULL) 1032 { 1033 if (!tp->private->dying) 1034 return 0; 1035 1036 delete_thread (ptid); 1037 tp = NULL; 1038 } 1039 } 1040 1041 if (target_has_execution) 1042 check_thread_signals (); 1043 1044 if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE) 1045 return 0; /* A zombie thread -- do not attach. */ 1046 1047 /* Under GNU/Linux, we have to attach to each and every thread. */ 1048 if (target_has_execution 1049 && tp == NULL 1050 && lin_lwp_attach_lwp (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid))) < 0) 1051 return 0; 1052 1053 /* Construct the thread's private data. */ 1054 private = xmalloc (sizeof (struct private_thread_info)); 1055 memset (private, 0, sizeof (struct private_thread_info)); 1056 1057 /* A thread ID of zero may mean the thread library has not initialized 1058 yet. But we shouldn't even get here if that's the case. FIXME: 1059 if we change GDB to always have at least one thread in the thread 1060 list this will have to go somewhere else; maybe private == NULL 1061 until the thread_db target claims it. */ 1062 gdb_assert (ti_p->ti_tid != 0); 1063 private->th = *th_p; 1064 private->tid = ti_p->ti_tid; 1065 1066 /* Add the thread to GDB's thread list. */ 1067 if (tp == NULL) 1068 add_thread_with_info (ptid, private); 1069 else 1070 tp->private = private; 1071 1072 info = get_thread_db_info (GET_PID (ptid)); 1073 1074 /* Enable thread event reporting for this thread, except when 1075 debugging a core file. */ 1076 if (target_has_execution) 1077 { 1078 err = info->td_thr_event_enable_p (th_p, 1); 1079 if (err != TD_OK) 1080 error (_("Cannot enable thread event reporting for %s: %s"), 1081 target_pid_to_str (ptid), thread_db_err_str (err)); 1082 } 1083 1084 return 1; 1085} 1086 1087static void 1088detach_thread (ptid_t ptid) 1089{ 1090 struct thread_info *thread_info; 1091 1092 /* Don't delete the thread now, because it still reports as active 1093 until it has executed a few instructions after the event 1094 breakpoint - if we deleted it now, "info threads" would cause us 1095 to re-attach to it. Just mark it as having had a TD_DEATH 1096 event. This means that we won't delete it from our thread list 1097 until we notice that it's dead (via prune_threads), or until 1098 something re-uses its thread ID. We'll report the thread exit 1099 when the underlying LWP dies. */ 1100 thread_info = find_thread_ptid (ptid); 1101 gdb_assert (thread_info != NULL && thread_info->private != NULL); 1102 thread_info->private->dying = 1; 1103} 1104 1105static void 1106thread_db_detach (struct target_ops *ops, char *args, int from_tty) 1107{ 1108 struct target_ops *target_beneath = find_target_beneath (ops); 1109 struct thread_db_info *info; 1110 1111 info = get_thread_db_info (GET_PID (inferior_ptid)); 1112 1113 if (info) 1114 { 1115 if (target_has_execution) 1116 { 1117 disable_thread_event_reporting (info); 1118 1119 /* Delete the old thread event breakpoints. Note that 1120 unlike when mourning, we can remove them here because 1121 there's still a live inferior to poke at. In any case, 1122 GDB will not try to insert anything in the inferior when 1123 removing a breakpoint. */ 1124 remove_thread_event_breakpoints (); 1125 } 1126 1127 delete_thread_db_info (GET_PID (inferior_ptid)); 1128 } 1129 1130 target_beneath->to_detach (target_beneath, args, from_tty); 1131 1132 /* NOTE: From this point on, inferior_ptid is null_ptid. */ 1133 1134 /* If there are no more processes using libpthread, detach the 1135 thread_db target ops. */ 1136 if (!thread_db_list) 1137 unpush_target (&thread_db_ops); 1138} 1139 1140/* Check if PID is currently stopped at the location of a thread event 1141 breakpoint location. If it is, read the event message and act upon 1142 the event. */ 1143 1144static void 1145check_event (ptid_t ptid) 1146{ 1147 struct regcache *regcache = get_thread_regcache (ptid); 1148 struct gdbarch *gdbarch = get_regcache_arch (regcache); 1149 td_event_msg_t msg; 1150 td_thrinfo_t ti; 1151 td_err_e err; 1152 CORE_ADDR stop_pc; 1153 int loop = 0; 1154 struct thread_db_info *info; 1155 1156 info = get_thread_db_info (GET_PID (ptid)); 1157 1158 /* Bail out early if we're not at a thread event breakpoint. */ 1159 stop_pc = regcache_read_pc (regcache) 1160 - gdbarch_decr_pc_after_break (gdbarch); 1161 if (stop_pc != info->td_create_bp_addr 1162 && stop_pc != info->td_death_bp_addr) 1163 return; 1164 1165 /* Access an lwp we know is stopped. */ 1166 info->proc_handle.ptid = ptid; 1167 1168 /* If we have only looked at the first thread before libpthread was 1169 initialized, we may not know its thread ID yet. Make sure we do 1170 before we add another thread to the list. */ 1171 if (!have_threads (ptid)) 1172 thread_db_find_new_threads_1 (ptid); 1173 1174 /* If we are at a create breakpoint, we do not know what new lwp 1175 was created and cannot specifically locate the event message for it. 1176 We have to call td_ta_event_getmsg() to get 1177 the latest message. Since we have no way of correlating whether 1178 the event message we get back corresponds to our breakpoint, we must 1179 loop and read all event messages, processing them appropriately. 1180 This guarantees we will process the correct message before continuing 1181 from the breakpoint. 1182 1183 Currently, death events are not enabled. If they are enabled, 1184 the death event can use the td_thr_event_getmsg() interface to 1185 get the message specifically for that lwp and avoid looping 1186 below. */ 1187 1188 loop = 1; 1189 1190 do 1191 { 1192 err = info->td_ta_event_getmsg_p (info->thread_agent, &msg); 1193 if (err != TD_OK) 1194 { 1195 if (err == TD_NOMSG) 1196 return; 1197 1198 error (_("Cannot get thread event message: %s"), 1199 thread_db_err_str (err)); 1200 } 1201 1202 err = info->td_thr_get_info_p (msg.th_p, &ti); 1203 if (err != TD_OK) 1204 error (_("Cannot get thread info: %s"), thread_db_err_str (err)); 1205 1206 ptid = ptid_build (GET_PID (ptid), ti.ti_lid, 0); 1207 1208 switch (msg.event) 1209 { 1210 case TD_CREATE: 1211 /* Call attach_thread whether or not we already know about a 1212 thread with this thread ID. */ 1213 attach_thread (ptid, msg.th_p, &ti); 1214 1215 break; 1216 1217 case TD_DEATH: 1218 1219 if (!in_thread_list (ptid)) 1220 error (_("Spurious thread death event.")); 1221 1222 detach_thread (ptid); 1223 1224 break; 1225 1226 default: 1227 error (_("Spurious thread event.")); 1228 } 1229 } 1230 while (loop); 1231} 1232 1233static ptid_t 1234thread_db_wait (struct target_ops *ops, 1235 ptid_t ptid, struct target_waitstatus *ourstatus, 1236 int options) 1237{ 1238 struct thread_db_info *info; 1239 struct target_ops *beneath = find_target_beneath (ops); 1240 1241 ptid = beneath->to_wait (beneath, ptid, ourstatus, options); 1242 1243 if (ourstatus->kind == TARGET_WAITKIND_IGNORE) 1244 return ptid; 1245 1246 if (ourstatus->kind == TARGET_WAITKIND_EXITED 1247 || ourstatus->kind == TARGET_WAITKIND_SIGNALLED) 1248 return ptid; 1249 1250 info = get_thread_db_info (GET_PID (ptid)); 1251 1252 /* If this process isn't using thread_db, we're done. */ 1253 if (info == NULL) 1254 return ptid; 1255 1256 if (ourstatus->kind == TARGET_WAITKIND_EXECD) 1257 { 1258 /* New image, it may or may not end up using thread_db. Assume 1259 not unless we find otherwise. */ 1260 delete_thread_db_info (GET_PID (ptid)); 1261 if (!thread_db_list) 1262 unpush_target (&thread_db_ops); 1263 1264 /* Thread event breakpoints are deleted by 1265 update_breakpoints_after_exec. */ 1266 1267 return ptid; 1268 } 1269 1270 /* If we do not know about the main thread yet, this would be a good time to 1271 find it. */ 1272 if (ourstatus->kind == TARGET_WAITKIND_STOPPED && !have_threads (ptid)) 1273 thread_db_find_new_threads_1 (ptid); 1274 1275 if (ourstatus->kind == TARGET_WAITKIND_STOPPED 1276 && ourstatus->value.sig == TARGET_SIGNAL_TRAP) 1277 /* Check for a thread event. */ 1278 check_event (ptid); 1279 1280 if (have_threads (ptid)) 1281 { 1282 /* Change ptids back into the higher level PID + TID format. If 1283 the thread is dead and no longer on the thread list, we will 1284 get back a dead ptid. This can occur if the thread death 1285 event gets postponed by other simultaneous events. In such a 1286 case, we want to just ignore the event and continue on. */ 1287 1288 ptid = thread_from_lwp (ptid); 1289 if (GET_PID (ptid) == -1) 1290 ourstatus->kind = TARGET_WAITKIND_SPURIOUS; 1291 } 1292 1293 return ptid; 1294} 1295 1296static void 1297thread_db_mourn_inferior (struct target_ops *ops) 1298{ 1299 struct target_ops *target_beneath = find_target_beneath (ops); 1300 1301 delete_thread_db_info (GET_PID (inferior_ptid)); 1302 1303 target_beneath->to_mourn_inferior (target_beneath); 1304 1305 /* Delete the old thread event breakpoints. Do this after mourning 1306 the inferior, so that we don't try to uninsert them. */ 1307 remove_thread_event_breakpoints (); 1308 1309 /* Detach thread_db target ops. */ 1310 if (!thread_db_list) 1311 unpush_target (ops); 1312} 1313 1314struct callback_data 1315{ 1316 struct thread_db_info *info; 1317 int new_threads; 1318}; 1319 1320static int 1321find_new_threads_callback (const td_thrhandle_t *th_p, void *data) 1322{ 1323 td_thrinfo_t ti; 1324 td_err_e err; 1325 ptid_t ptid; 1326 struct thread_info *tp; 1327 struct callback_data *cb_data = data; 1328 struct thread_db_info *info = cb_data->info; 1329 1330 err = info->td_thr_get_info_p (th_p, &ti); 1331 if (err != TD_OK) 1332 error (_("find_new_threads_callback: cannot get thread info: %s"), 1333 thread_db_err_str (err)); 1334 1335 if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE) 1336 return 0; /* A zombie -- ignore. */ 1337 1338 if (ti.ti_tid == 0 && target_has_execution) 1339 { 1340 /* A thread ID of zero means that this is the main thread, but 1341 glibc has not yet initialized thread-local storage and the 1342 pthread library. We do not know what the thread's TID will 1343 be yet. Just enable event reporting and otherwise ignore 1344 it. */ 1345 1346 /* In that case, we're not stopped in a fork syscall and don't 1347 need this glibc bug workaround. */ 1348 info->need_stale_parent_threads_check = 0; 1349 1350 err = info->td_thr_event_enable_p (th_p, 1); 1351 if (err != TD_OK) 1352 error (_("Cannot enable thread event reporting for LWP %d: %s"), 1353 (int) ti.ti_lid, thread_db_err_str (err)); 1354 1355 return 0; 1356 } 1357 1358 /* Ignore stale parent threads, caused by glibc/BZ5983. This is a 1359 bit expensive, as it needs to open /proc/pid/status, so try to 1360 avoid doing the work if we know we don't have to. */ 1361 if (info->need_stale_parent_threads_check) 1362 { 1363 int tgid = linux_proc_get_tgid (ti.ti_lid); 1364 1365 if (tgid != -1 && tgid != info->pid) 1366 return 0; 1367 } 1368 1369 ptid = ptid_build (info->pid, ti.ti_lid, 0); 1370 tp = find_thread_ptid (ptid); 1371 if (tp == NULL || tp->private == NULL) 1372 { 1373 if (attach_thread (ptid, th_p, &ti)) 1374 cb_data->new_threads += 1; 1375 else 1376 /* Problem attaching this thread; perhaps it exited before we 1377 could attach it? 1378 This could mean that the thread list inside glibc itself is in 1379 inconsistent state, and libthread_db could go on looping forever 1380 (observed with glibc-2.3.6). To prevent that, terminate 1381 iteration: thread_db_find_new_threads_2 will retry. */ 1382 return 1; 1383 } 1384 1385 return 0; 1386} 1387 1388/* Helper for thread_db_find_new_threads_2. 1389 Returns number of new threads found. */ 1390 1391static int 1392find_new_threads_once (struct thread_db_info *info, int iteration, 1393 td_err_e *errp) 1394{ 1395 volatile struct gdb_exception except; 1396 struct callback_data data; 1397 td_err_e err = TD_ERR; 1398 1399 data.info = info; 1400 data.new_threads = 0; 1401 1402 TRY_CATCH (except, RETURN_MASK_ERROR) 1403 { 1404 /* Iterate over all user-space threads to discover new threads. */ 1405 err = info->td_ta_thr_iter_p (info->thread_agent, 1406 find_new_threads_callback, 1407 &data, 1408 TD_THR_ANY_STATE, 1409 TD_THR_LOWEST_PRIORITY, 1410 TD_SIGNO_MASK, 1411 TD_THR_ANY_USER_FLAGS); 1412 } 1413 1414 if (libthread_db_debug) 1415 { 1416 if (except.reason < 0) 1417 exception_fprintf (gdb_stderr, except, 1418 "Warning: find_new_threads_once: "); 1419 1420 printf_filtered (_("Found %d new threads in iteration %d.\n"), 1421 data.new_threads, iteration); 1422 } 1423 1424 if (errp != NULL) 1425 *errp = err; 1426 1427 return data.new_threads; 1428} 1429 1430/* Search for new threads, accessing memory through stopped thread 1431 PTID. If UNTIL_NO_NEW is true, repeat searching until several 1432 searches in a row do not discover any new threads. */ 1433 1434static void 1435thread_db_find_new_threads_2 (ptid_t ptid, int until_no_new) 1436{ 1437 td_err_e err; 1438 struct thread_db_info *info; 1439 int pid = ptid_get_pid (ptid); 1440 int i, loop; 1441 1442 if (target_has_execution) 1443 { 1444 struct lwp_info *lp; 1445 1446 /* In linux, we can only read memory through a stopped lwp. */ 1447 ALL_LWPS (lp, ptid) 1448 if (lp->stopped && ptid_get_pid (lp->ptid) == pid) 1449 break; 1450 1451 if (!lp) 1452 /* There is no stopped thread. Bail out. */ 1453 return; 1454 } 1455 1456 info = get_thread_db_info (GET_PID (ptid)); 1457 1458 /* Access an lwp we know is stopped. */ 1459 info->proc_handle.ptid = ptid; 1460 1461 if (until_no_new) 1462 { 1463 /* Require 4 successive iterations which do not find any new threads. 1464 The 4 is a heuristic: there is an inherent race here, and I have 1465 seen that 2 iterations in a row are not always sufficient to 1466 "capture" all threads. */ 1467 for (i = 0, loop = 0; loop < 4; ++i, ++loop) 1468 if (find_new_threads_once (info, i, NULL) != 0) 1469 /* Found some new threads. Restart the loop from beginning. */ 1470 loop = -1; 1471 } 1472 else 1473 { 1474 find_new_threads_once (info, 0, &err); 1475 if (err != TD_OK) 1476 error (_("Cannot find new threads: %s"), thread_db_err_str (err)); 1477 } 1478} 1479 1480static void 1481thread_db_find_new_threads_1 (ptid_t ptid) 1482{ 1483 thread_db_find_new_threads_2 (ptid, 0); 1484} 1485 1486static int 1487update_thread_core (struct lwp_info *info, void *closure) 1488{ 1489 info->core = linux_nat_core_of_thread_1 (info->ptid); 1490 return 0; 1491} 1492 1493static void 1494thread_db_find_new_threads (struct target_ops *ops) 1495{ 1496 struct thread_db_info *info; 1497 1498 info = get_thread_db_info (GET_PID (inferior_ptid)); 1499 1500 if (info == NULL) 1501 return; 1502 1503 thread_db_find_new_threads_1 (inferior_ptid); 1504 1505 if (target_has_execution) 1506 iterate_over_lwps (minus_one_ptid /* iterate over all */, 1507 update_thread_core, NULL); 1508} 1509 1510static char * 1511thread_db_pid_to_str (struct target_ops *ops, ptid_t ptid) 1512{ 1513 struct thread_info *thread_info = find_thread_ptid (ptid); 1514 struct target_ops *beneath; 1515 1516 if (thread_info != NULL && thread_info->private != NULL) 1517 { 1518 static char buf[64]; 1519 thread_t tid; 1520 1521 tid = thread_info->private->tid; 1522 snprintf (buf, sizeof (buf), "Thread 0x%lx (LWP %ld)", 1523 tid, GET_LWP (ptid)); 1524 1525 return buf; 1526 } 1527 1528 beneath = find_target_beneath (ops); 1529 if (beneath->to_pid_to_str (beneath, ptid)) 1530 return beneath->to_pid_to_str (beneath, ptid); 1531 1532 return normal_pid_to_str (ptid); 1533} 1534 1535/* Return a string describing the state of the thread specified by 1536 INFO. */ 1537 1538static char * 1539thread_db_extra_thread_info (struct thread_info *info) 1540{ 1541 if (info->private == NULL) 1542 return NULL; 1543 1544 if (info->private->dying) 1545 return "Exiting"; 1546 1547 return NULL; 1548} 1549 1550/* Get the address of the thread local variable in load module LM which 1551 is stored at OFFSET within the thread local storage for thread PTID. */ 1552 1553static CORE_ADDR 1554thread_db_get_thread_local_address (struct target_ops *ops, 1555 ptid_t ptid, 1556 CORE_ADDR lm, 1557 CORE_ADDR offset) 1558{ 1559 struct thread_info *thread_info; 1560 struct target_ops *beneath; 1561 1562 /* If we have not discovered any threads yet, check now. */ 1563 if (!have_threads (ptid)) 1564 thread_db_find_new_threads_1 (ptid); 1565 1566 /* Find the matching thread. */ 1567 thread_info = find_thread_ptid (ptid); 1568 1569 if (thread_info != NULL && thread_info->private != NULL) 1570 { 1571 td_err_e err; 1572 psaddr_t address; 1573 struct thread_db_info *info; 1574 1575 info = get_thread_db_info (GET_PID (ptid)); 1576 1577 /* glibc doesn't provide the needed interface. */ 1578 if (!info->td_thr_tls_get_addr_p) 1579 throw_error (TLS_NO_LIBRARY_SUPPORT_ERROR, 1580 _("No TLS library support")); 1581 1582 /* Caller should have verified that lm != 0. */ 1583 gdb_assert (lm != 0); 1584 1585 /* Finally, get the address of the variable. */ 1586 /* Note the cast through uintptr_t: this interface only works if 1587 a target address fits in a psaddr_t, which is a host pointer. 1588 So a 32-bit debugger can not access 64-bit TLS through this. */ 1589 err = info->td_thr_tls_get_addr_p (&thread_info->private->th, 1590 (psaddr_t)(uintptr_t) lm, 1591 offset, &address); 1592 1593#ifdef THREAD_DB_HAS_TD_NOTALLOC 1594 /* The memory hasn't been allocated, yet. */ 1595 if (err == TD_NOTALLOC) 1596 /* Now, if libthread_db provided the initialization image's 1597 address, we *could* try to build a non-lvalue value from 1598 the initialization image. */ 1599 throw_error (TLS_NOT_ALLOCATED_YET_ERROR, 1600 _("TLS not allocated yet")); 1601#endif 1602 1603 /* Something else went wrong. */ 1604 if (err != TD_OK) 1605 throw_error (TLS_GENERIC_ERROR, 1606 (("%s")), thread_db_err_str (err)); 1607 1608 /* Cast assuming host == target. Joy. */ 1609 /* Do proper sign extension for the target. */ 1610 gdb_assert (exec_bfd); 1611 return (bfd_get_sign_extend_vma (exec_bfd) > 0 1612 ? (CORE_ADDR) (intptr_t) address 1613 : (CORE_ADDR) (uintptr_t) address); 1614 } 1615 1616 beneath = find_target_beneath (ops); 1617 if (beneath->to_get_thread_local_address) 1618 return beneath->to_get_thread_local_address (beneath, ptid, lm, offset); 1619 else 1620 throw_error (TLS_GENERIC_ERROR, 1621 _("TLS not supported on this target")); 1622} 1623 1624/* Callback routine used to find a thread based on the TID part of 1625 its PTID. */ 1626 1627static int 1628thread_db_find_thread_from_tid (struct thread_info *thread, void *data) 1629{ 1630 long *tid = (long *) data; 1631 1632 if (thread->private->tid == *tid) 1633 return 1; 1634 1635 return 0; 1636} 1637 1638/* Implement the to_get_ada_task_ptid target method for this target. */ 1639 1640static ptid_t 1641thread_db_get_ada_task_ptid (long lwp, long thread) 1642{ 1643 struct thread_info *thread_info; 1644 1645 thread_db_find_new_threads_1 (inferior_ptid); 1646 thread_info = iterate_over_threads (thread_db_find_thread_from_tid, &thread); 1647 1648 gdb_assert (thread_info != NULL); 1649 1650 return (thread_info->ptid); 1651} 1652 1653static void 1654thread_db_resume (struct target_ops *ops, 1655 ptid_t ptid, int step, enum target_signal signo) 1656{ 1657 struct target_ops *beneath = find_target_beneath (ops); 1658 struct thread_db_info *info; 1659 1660 if (ptid_equal (ptid, minus_one_ptid)) 1661 info = get_thread_db_info (GET_PID (inferior_ptid)); 1662 else 1663 info = get_thread_db_info (GET_PID (ptid)); 1664 1665 /* This workaround is only needed for child fork lwps stopped in a 1666 PTRACE_O_TRACEFORK event. When the inferior is resumed, the 1667 workaround can be disabled. */ 1668 if (info) 1669 info->need_stale_parent_threads_check = 0; 1670 1671 beneath->to_resume (beneath, ptid, step, signo); 1672} 1673 1674static void 1675init_thread_db_ops (void) 1676{ 1677 thread_db_ops.to_shortname = "multi-thread"; 1678 thread_db_ops.to_longname = "multi-threaded child process."; 1679 thread_db_ops.to_doc = "Threads and pthreads support."; 1680 thread_db_ops.to_detach = thread_db_detach; 1681 thread_db_ops.to_wait = thread_db_wait; 1682 thread_db_ops.to_resume = thread_db_resume; 1683 thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior; 1684 thread_db_ops.to_find_new_threads = thread_db_find_new_threads; 1685 thread_db_ops.to_pid_to_str = thread_db_pid_to_str; 1686 thread_db_ops.to_stratum = thread_stratum; 1687 thread_db_ops.to_has_thread_control = tc_schedlock; 1688 thread_db_ops.to_get_thread_local_address 1689 = thread_db_get_thread_local_address; 1690 thread_db_ops.to_extra_thread_info = thread_db_extra_thread_info; 1691 thread_db_ops.to_get_ada_task_ptid = thread_db_get_ada_task_ptid; 1692 thread_db_ops.to_magic = OPS_MAGIC; 1693} 1694 1695/* Provide a prototype to silence -Wmissing-prototypes. */ 1696extern initialize_file_ftype _initialize_thread_db; 1697 1698void 1699_initialize_thread_db (void) 1700{ 1701 init_thread_db_ops (); 1702 add_target (&thread_db_ops); 1703 1704 /* Defer loading of libthread_db.so until inferior is running. 1705 This allows gdb to load correct libthread_db for a given 1706 executable -- there could be mutiple versions of glibc, 1707 compiled with LinuxThreads or NPTL, and until there is 1708 a running inferior, we can't tell which libthread_db is 1709 the correct one to load. */ 1710 1711 libthread_db_search_path = xstrdup (LIBTHREAD_DB_SEARCH_PATH); 1712 1713 add_setshow_optional_filename_cmd ("libthread-db-search-path", 1714 class_support, 1715 &libthread_db_search_path, _("\ 1716Set search path for libthread_db."), _("\ 1717Show the current search path or libthread_db."), _("\ 1718This path is used to search for libthread_db to be loaded into \ 1719gdb itself."), 1720 NULL, 1721 NULL, 1722 &setlist, &showlist); 1723 1724 add_setshow_zinteger_cmd ("libthread-db", class_maintenance, 1725 &libthread_db_debug, _("\ 1726Set libthread-db debugging."), _("\ 1727Show libthread-db debugging."), _("\ 1728When non-zero, libthread-db debugging is enabled."), 1729 NULL, 1730 show_libthread_db_debug, 1731 &setdebuglist, &showdebuglist); 1732 1733 /* Add ourselves to objfile event chain. */ 1734 observer_attach_new_objfile (thread_db_new_objfile); 1735} 1736