linux-thread-db.c revision 1.8
1/* libthread_db assisted debugging support, generic parts. 2 3 Copyright (C) 1999-2019 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20#include "defs.h" 21#include <dlfcn.h> 22#include "gdb_proc_service.h" 23#include "nat/gdb_thread_db.h" 24#include "common/gdb_vecs.h" 25#include "bfd.h" 26#include "command.h" 27#include "gdbcmd.h" 28#include "gdbthread.h" 29#include "inferior.h" 30#include "infrun.h" 31#include "symfile.h" 32#include "objfiles.h" 33#include "target.h" 34#include "regcache.h" 35#include "solib.h" 36#include "solib-svr4.h" 37#include "gdbcore.h" 38#include "observable.h" 39#include "linux-nat.h" 40#include "nat/linux-procfs.h" 41#include "nat/linux-ptrace.h" 42#include "nat/linux-osdata.h" 43#include "auto-load.h" 44#include "cli/cli-utils.h" 45#include <signal.h> 46#include <ctype.h> 47#include "nat/linux-namespaces.h" 48#include <algorithm> 49#include "common/pathstuff.h" 50#include "valprint.h" 51 52/* GNU/Linux libthread_db support. 53 54 libthread_db is a library, provided along with libpthread.so, which 55 exposes the internals of the thread library to a debugger. It 56 allows GDB to find existing threads, new threads as they are 57 created, thread IDs (usually, the result of pthread_self), and 58 thread-local variables. 59 60 The libthread_db interface originates on Solaris, where it is both 61 more powerful and more complicated. This implementation only works 62 for NPTL, the glibc threading library. It assumes that each thread 63 is permanently assigned to a single light-weight process (LWP). At 64 some point it also supported the older LinuxThreads library, but it 65 no longer does. 66 67 libthread_db-specific information is stored in the "private" field 68 of struct thread_info. When the field is NULL we do not yet have 69 information about the new thread; this could be temporary (created, 70 but the thread library's data structures do not reflect it yet) 71 or permanent (created using clone instead of pthread_create). 72 73 Process IDs managed by linux-thread-db.c match those used by 74 linux-nat.c: a common PID for all processes, an LWP ID for each 75 thread, and no TID. We save the TID in private. Keeping it out 76 of the ptid_t prevents thread IDs changing when libpthread is 77 loaded or unloaded. */ 78 79static const target_info thread_db_target_info = { 80 "multi-thread", 81 N_("multi-threaded child process."), 82 N_("Threads and pthreads support.") 83}; 84 85class thread_db_target final : public target_ops 86{ 87public: 88 const target_info &info () const override 89 { return thread_db_target_info; } 90 91 strata stratum () const override { return thread_stratum; } 92 93 void detach (inferior *, int) override; 94 ptid_t wait (ptid_t, struct target_waitstatus *, int) override; 95 void resume (ptid_t, int, enum gdb_signal) override; 96 void mourn_inferior () override; 97 void update_thread_list () override; 98 const char *pid_to_str (ptid_t) override; 99 CORE_ADDR get_thread_local_address (ptid_t ptid, 100 CORE_ADDR load_module_addr, 101 CORE_ADDR offset) override; 102 const char *extra_thread_info (struct thread_info *) override; 103 ptid_t get_ada_task_ptid (long lwp, long thread) override; 104 105 thread_info *thread_handle_to_thread_info (const gdb_byte *thread_handle, 106 int handle_len, 107 inferior *inf) override; 108}; 109 110static char *libthread_db_search_path; 111 112/* Set to non-zero if thread_db auto-loading is enabled 113 by the "set auto-load libthread-db" command. */ 114static int auto_load_thread_db = 1; 115 116/* Set to non-zero if load-time libthread_db tests have been enabled 117 by the "maintenence set check-libthread-db" command. */ 118static int check_thread_db_on_load = 0; 119 120/* "show" command for the auto_load_thread_db configuration variable. */ 121 122static void 123show_auto_load_thread_db (struct ui_file *file, int from_tty, 124 struct cmd_list_element *c, const char *value) 125{ 126 fprintf_filtered (file, _("Auto-loading of inferior specific libthread_db " 127 "is %s.\n"), 128 value); 129} 130 131static void 132set_libthread_db_search_path (const char *ignored, int from_tty, 133 struct cmd_list_element *c) 134{ 135 if (*libthread_db_search_path == '\0') 136 { 137 xfree (libthread_db_search_path); 138 libthread_db_search_path = xstrdup (LIBTHREAD_DB_SEARCH_PATH); 139 } 140} 141 142/* If non-zero, print details of libthread_db processing. */ 143 144static unsigned int libthread_db_debug; 145 146static void 147show_libthread_db_debug (struct ui_file *file, int from_tty, 148 struct cmd_list_element *c, const char *value) 149{ 150 fprintf_filtered (file, _("libthread-db debugging is %s.\n"), value); 151} 152 153/* If we're running on GNU/Linux, we must explicitly attach to any new 154 threads. */ 155 156/* This module's target vector. */ 157static thread_db_target the_thread_db_target; 158 159/* Non-zero if we have determined the signals used by the threads 160 library. */ 161static int thread_signals; 162static sigset_t thread_stop_set; 163static sigset_t thread_print_set; 164 165struct thread_db_info 166{ 167 struct thread_db_info *next; 168 169 /* Process id this object refers to. */ 170 int pid; 171 172 /* Handle from dlopen for libthread_db.so. */ 173 void *handle; 174 175 /* Absolute pathname from gdb_realpath to disk file used for dlopen-ing 176 HANDLE. It may be NULL for system library. */ 177 char *filename; 178 179 /* Structure that identifies the child process for the 180 <proc_service.h> interface. */ 181 struct ps_prochandle proc_handle; 182 183 /* Connection to the libthread_db library. */ 184 td_thragent_t *thread_agent; 185 186 /* True if we need to apply the workaround for glibc/BZ5983. When 187 we catch a PTRACE_O_TRACEFORK, and go query the child's thread 188 list, nptl_db returns the parent's threads in addition to the new 189 (single) child thread. If this flag is set, we do extra work to 190 be able to ignore such stale entries. */ 191 int need_stale_parent_threads_check; 192 193 /* Pointers to the libthread_db functions. */ 194 195 td_init_ftype *td_init_p; 196 td_ta_new_ftype *td_ta_new_p; 197 td_ta_delete_ftype *td_ta_delete_p; 198 td_ta_map_lwp2thr_ftype *td_ta_map_lwp2thr_p; 199 td_ta_thr_iter_ftype *td_ta_thr_iter_p; 200 td_thr_get_info_ftype *td_thr_get_info_p; 201 td_thr_tls_get_addr_ftype *td_thr_tls_get_addr_p; 202 td_thr_tlsbase_ftype *td_thr_tlsbase_p; 203}; 204 205/* List of known processes using thread_db, and the required 206 bookkeeping. */ 207struct thread_db_info *thread_db_list; 208 209static void thread_db_find_new_threads_1 (thread_info *stopped); 210static void thread_db_find_new_threads_2 (thread_info *stopped, 211 bool until_no_new); 212 213static void check_thread_signals (void); 214 215static struct thread_info *record_thread 216 (struct thread_db_info *info, struct thread_info *tp, 217 ptid_t ptid, const td_thrhandle_t *th_p, const td_thrinfo_t *ti_p); 218 219/* Add the current inferior to the list of processes using libpthread. 220 Return a pointer to the newly allocated object that was added to 221 THREAD_DB_LIST. HANDLE is the handle returned by dlopen'ing 222 LIBTHREAD_DB_SO. */ 223 224static struct thread_db_info * 225add_thread_db_info (void *handle) 226{ 227 struct thread_db_info *info = XCNEW (struct thread_db_info); 228 229 info->pid = inferior_ptid.pid (); 230 info->handle = handle; 231 232 /* The workaround works by reading from /proc/pid/status, so it is 233 disabled for core files. */ 234 if (target_has_execution) 235 info->need_stale_parent_threads_check = 1; 236 237 info->next = thread_db_list; 238 thread_db_list = info; 239 240 return info; 241} 242 243/* Return the thread_db_info object representing the bookkeeping 244 related to process PID, if any; NULL otherwise. */ 245 246static struct thread_db_info * 247get_thread_db_info (int pid) 248{ 249 struct thread_db_info *info; 250 251 for (info = thread_db_list; info; info = info->next) 252 if (pid == info->pid) 253 return info; 254 255 return NULL; 256} 257 258static const char *thread_db_err_str (td_err_e err); 259 260/* When PID has exited or has been detached, we no longer want to keep 261 track of it as using libpthread. Call this function to discard 262 thread_db related info related to PID. Note that this closes 263 LIBTHREAD_DB_SO's dlopen'ed handle. */ 264 265static void 266delete_thread_db_info (int pid) 267{ 268 struct thread_db_info *info, *info_prev; 269 270 info_prev = NULL; 271 272 for (info = thread_db_list; info; info_prev = info, info = info->next) 273 if (pid == info->pid) 274 break; 275 276 if (info == NULL) 277 return; 278 279 if (info->thread_agent != NULL && info->td_ta_delete_p != NULL) 280 { 281 td_err_e err = info->td_ta_delete_p (info->thread_agent); 282 283 if (err != TD_OK) 284 warning (_("Cannot deregister process %d from libthread_db: %s"), 285 pid, thread_db_err_str (err)); 286 info->thread_agent = NULL; 287 } 288 289 if (info->handle != NULL) 290 dlclose (info->handle); 291 292 xfree (info->filename); 293 294 if (info_prev) 295 info_prev->next = info->next; 296 else 297 thread_db_list = info->next; 298 299 xfree (info); 300} 301 302/* Use "struct private_thread_info" to cache thread state. This is 303 a substantial optimization. */ 304 305struct thread_db_thread_info : public private_thread_info 306{ 307 /* Flag set when we see a TD_DEATH event for this thread. */ 308 bool dying = false; 309 310 /* Cached thread state. */ 311 td_thrhandle_t th {}; 312 thread_t tid {}; 313}; 314 315static thread_db_thread_info * 316get_thread_db_thread_info (thread_info *thread) 317{ 318 return static_cast<thread_db_thread_info *> (thread->priv.get ()); 319} 320 321static const char * 322thread_db_err_str (td_err_e err) 323{ 324 static char buf[64]; 325 326 switch (err) 327 { 328 case TD_OK: 329 return "generic 'call succeeded'"; 330 case TD_ERR: 331 return "generic error"; 332 case TD_NOTHR: 333 return "no thread to satisfy query"; 334 case TD_NOSV: 335 return "no sync handle to satisfy query"; 336 case TD_NOLWP: 337 return "no LWP to satisfy query"; 338 case TD_BADPH: 339 return "invalid process handle"; 340 case TD_BADTH: 341 return "invalid thread handle"; 342 case TD_BADSH: 343 return "invalid synchronization handle"; 344 case TD_BADTA: 345 return "invalid thread agent"; 346 case TD_BADKEY: 347 return "invalid key"; 348 case TD_NOMSG: 349 return "no event message for getmsg"; 350 case TD_NOFPREGS: 351 return "FPU register set not available"; 352 case TD_NOLIBTHREAD: 353 return "application not linked with libthread"; 354 case TD_NOEVENT: 355 return "requested event is not supported"; 356 case TD_NOCAPAB: 357 return "capability not available"; 358 case TD_DBERR: 359 return "debugger service failed"; 360 case TD_NOAPLIC: 361 return "operation not applicable to"; 362 case TD_NOTSD: 363 return "no thread-specific data for this thread"; 364 case TD_MALLOC: 365 return "malloc failed"; 366 case TD_PARTIALREG: 367 return "only part of register set was written/read"; 368 case TD_NOXREGS: 369 return "X register set not available for this thread"; 370#ifdef THREAD_DB_HAS_TD_NOTALLOC 371 case TD_NOTALLOC: 372 return "thread has not yet allocated TLS for given module"; 373#endif 374#ifdef THREAD_DB_HAS_TD_VERSION 375 case TD_VERSION: 376 return "versions of libpthread and libthread_db do not match"; 377#endif 378#ifdef THREAD_DB_HAS_TD_NOTLS 379 case TD_NOTLS: 380 return "there is no TLS segment in the given module"; 381#endif 382 default: 383 snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err); 384 return buf; 385 } 386} 387 388/* Fetch the user-level thread id of PTID. STOPPED is a stopped 389 thread that we can use to access memory. */ 390 391static struct thread_info * 392thread_from_lwp (thread_info *stopped, ptid_t ptid) 393{ 394 td_thrhandle_t th; 395 td_thrinfo_t ti; 396 td_err_e err; 397 struct thread_db_info *info; 398 struct thread_info *tp; 399 400 /* Just in case td_ta_map_lwp2thr doesn't initialize it completely. */ 401 th.th_unique = 0; 402 403 /* This ptid comes from linux-nat.c, which should always fill in the 404 LWP. */ 405 gdb_assert (ptid.lwp () != 0); 406 407 info = get_thread_db_info (ptid.pid ()); 408 409 /* Access an lwp we know is stopped. */ 410 info->proc_handle.thread = stopped; 411 err = info->td_ta_map_lwp2thr_p (info->thread_agent, ptid.lwp (), 412 &th); 413 if (err != TD_OK) 414 error (_("Cannot find user-level thread for LWP %ld: %s"), 415 ptid.lwp (), thread_db_err_str (err)); 416 417 err = info->td_thr_get_info_p (&th, &ti); 418 if (err != TD_OK) 419 error (_("thread_get_info_callback: cannot get thread info: %s"), 420 thread_db_err_str (err)); 421 422 /* Fill the cache. */ 423 tp = find_thread_ptid (ptid); 424 return record_thread (info, tp, ptid, &th, &ti); 425} 426 427 428/* See linux-nat.h. */ 429 430int 431thread_db_notice_clone (ptid_t parent, ptid_t child) 432{ 433 struct thread_db_info *info; 434 435 info = get_thread_db_info (child.pid ()); 436 437 if (info == NULL) 438 return 0; 439 440 thread_info *stopped = find_thread_ptid (parent); 441 442 thread_from_lwp (stopped, child); 443 444 /* If we do not know about the main thread's pthread info yet, this 445 would be a good time to find it. */ 446 thread_from_lwp (stopped, parent); 447 return 1; 448} 449 450static void * 451verbose_dlsym (void *handle, const char *name) 452{ 453 void *sym = dlsym (handle, name); 454 if (sym == NULL) 455 warning (_("Symbol \"%s\" not found in libthread_db: %s"), 456 name, dlerror ()); 457 return sym; 458} 459 460/* Verify inferior's '\0'-terminated symbol VER_SYMBOL starts with "%d.%d" and 461 return 1 if this version is lower (and not equal) to 462 VER_MAJOR_MIN.VER_MINOR_MIN. Return 0 in all other cases. */ 463 464static int 465inferior_has_bug (const char *ver_symbol, int ver_major_min, int ver_minor_min) 466{ 467 struct bound_minimal_symbol version_msym; 468 CORE_ADDR version_addr; 469 gdb::unique_xmalloc_ptr<char> version; 470 int err, got, retval = 0; 471 472 version_msym = lookup_minimal_symbol (ver_symbol, NULL, NULL); 473 if (version_msym.minsym == NULL) 474 return 0; 475 476 version_addr = BMSYMBOL_VALUE_ADDRESS (version_msym); 477 got = target_read_string (version_addr, &version, 32, &err); 478 if (err == 0 && memchr (version.get (), 0, got) == version.get () + got - 1) 479 { 480 int major, minor; 481 482 retval = (sscanf (version.get (), "%d.%d", &major, &minor) == 2 483 && (major < ver_major_min 484 || (major == ver_major_min && minor < ver_minor_min))); 485 } 486 487 return retval; 488} 489 490/* Similar as thread_db_find_new_threads_1, but try to silently ignore errors 491 if appropriate. 492 493 Return 1 if the caller should abort libthread_db initialization. Return 0 494 otherwise. */ 495 496static int 497thread_db_find_new_threads_silently (thread_info *stopped) 498{ 499 500 TRY 501 { 502 thread_db_find_new_threads_2 (stopped, true); 503 } 504 505 CATCH (except, RETURN_MASK_ERROR) 506 { 507 if (libthread_db_debug) 508 exception_fprintf (gdb_stdlog, except, 509 "Warning: thread_db_find_new_threads_silently: "); 510 511 /* There is a bug fixed between nptl 2.6.1 and 2.7 by 512 commit 7d9d8bd18906fdd17364f372b160d7ab896ce909 513 where calls to td_thr_get_info fail with TD_ERR for statically linked 514 executables if td_thr_get_info is called before glibc has initialized 515 itself. 516 517 If the nptl bug is NOT present in the inferior and still thread_db 518 reports an error return 1. It means the inferior has corrupted thread 519 list and GDB should fall back only to LWPs. 520 521 If the nptl bug is present in the inferior return 0 to silently ignore 522 such errors, and let gdb enumerate threads again later. In such case 523 GDB cannot properly display LWPs if the inferior thread list is 524 corrupted. For core files it does not apply, no 'later enumeration' 525 is possible. */ 526 527 if (!target_has_execution || !inferior_has_bug ("nptl_version", 2, 7)) 528 { 529 exception_fprintf (gdb_stderr, except, 530 _("Warning: couldn't activate thread debugging " 531 "using libthread_db: ")); 532 return 1; 533 } 534 } 535 END_CATCH 536 537 return 0; 538} 539 540/* Lookup a library in which given symbol resides. 541 Note: this is looking in GDB process, not in the inferior. 542 Returns library name, or NULL. */ 543 544static const char * 545dladdr_to_soname (const void *addr) 546{ 547 Dl_info info; 548 549 if (dladdr (addr, &info) != 0) 550 return info.dli_fname; 551 return NULL; 552} 553 554/* State for check_thread_db_callback. */ 555 556struct check_thread_db_info 557{ 558 /* The libthread_db under test. */ 559 struct thread_db_info *info; 560 561 /* True if progress should be logged. */ 562 bool log_progress; 563 564 /* True if the callback was called. */ 565 bool threads_seen; 566 567 /* Name of last libthread_db function called. */ 568 const char *last_call; 569 570 /* Value returned by last libthread_db call. */ 571 td_err_e last_result; 572}; 573 574static struct check_thread_db_info *tdb_testinfo; 575 576/* Callback for check_thread_db. */ 577 578static int 579check_thread_db_callback (const td_thrhandle_t *th, void *arg) 580{ 581 gdb_assert (tdb_testinfo != NULL); 582 tdb_testinfo->threads_seen = true; 583 584#define LOG(fmt, args...) \ 585 do \ 586 { \ 587 if (tdb_testinfo->log_progress) \ 588 { \ 589 debug_printf (fmt, ## args); \ 590 gdb_flush (gdb_stdlog); \ 591 } \ 592 } \ 593 while (0) 594 595#define CHECK_1(expr, args...) \ 596 do \ 597 { \ 598 if (!(expr)) \ 599 { \ 600 LOG (" ... FAIL!\n"); \ 601 error (args); \ 602 } \ 603 } \ 604 while (0) 605 606#define CHECK(expr) \ 607 CHECK_1 (expr, "(%s) == false", #expr) 608 609#define CALL_UNCHECKED(func, args...) \ 610 do \ 611 { \ 612 tdb_testinfo->last_call = #func; \ 613 tdb_testinfo->last_result \ 614 = tdb_testinfo->info->func ## _p (args); \ 615 } \ 616 while (0) 617 618#define CHECK_CALL() \ 619 CHECK_1 (tdb_testinfo->last_result == TD_OK, \ 620 _("%s failed: %s"), \ 621 tdb_testinfo->last_call, \ 622 thread_db_err_str (tdb_testinfo->last_result)) \ 623 624#define CALL(func, args...) \ 625 do \ 626 { \ 627 CALL_UNCHECKED (func, args); \ 628 CHECK_CALL (); \ 629 } \ 630 while (0) 631 632 LOG (" Got thread"); 633 634 /* Check td_ta_thr_iter passed consistent arguments. */ 635 CHECK (th != NULL); 636 CHECK (arg == (void *) tdb_testinfo); 637 CHECK (th->th_ta_p == tdb_testinfo->info->thread_agent); 638 639 LOG (" %s", core_addr_to_string_nz ((CORE_ADDR) th->th_unique)); 640 641 /* Check td_thr_get_info. */ 642 td_thrinfo_t ti; 643 CALL (td_thr_get_info, th, &ti); 644 645 LOG (" => %d", ti.ti_lid); 646 647 CHECK (ti.ti_ta_p == th->th_ta_p); 648 CHECK (ti.ti_tid == (thread_t) th->th_unique); 649 650 /* Check td_ta_map_lwp2thr. */ 651 td_thrhandle_t th2; 652 memset (&th2, 23, sizeof (td_thrhandle_t)); 653 CALL_UNCHECKED (td_ta_map_lwp2thr, th->th_ta_p, ti.ti_lid, &th2); 654 655 if (tdb_testinfo->last_result == TD_ERR && !target_has_execution) 656 { 657 /* Some platforms require execution for td_ta_map_lwp2thr. */ 658 LOG (_("; can't map_lwp2thr")); 659 } 660 else 661 { 662 CHECK_CALL (); 663 664 LOG (" => %s", core_addr_to_string_nz ((CORE_ADDR) th2.th_unique)); 665 666 CHECK (memcmp (th, &th2, sizeof (td_thrhandle_t)) == 0); 667 } 668 669 /* Attempt TLS access. Assuming errno is TLS, this calls 670 thread_db_get_thread_local_address, which in turn calls 671 td_thr_tls_get_addr for live inferiors or td_thr_tlsbase 672 for core files. This test is skipped if the thread has 673 not been recorded; proceeding in that case would result 674 in the test having the side-effect of noticing threads 675 which seems wrong. 676 677 Note that in glibc's libthread_db td_thr_tls_get_addr is 678 a thin wrapper around td_thr_tlsbase; this check always 679 hits the bulk of the code. 680 681 Note also that we don't actually check any libthread_db 682 calls are made, we just assume they were; future changes 683 to how GDB accesses TLS could result in this passing 684 without exercising the calls it's supposed to. */ 685 ptid_t ptid = ptid_t (tdb_testinfo->info->pid, ti.ti_lid, 0); 686 struct thread_info *thread_info = find_thread_ptid (ptid); 687 if (thread_info != NULL && thread_info->priv != NULL) 688 { 689 LOG ("; errno"); 690 691 scoped_restore_current_thread restore_current_thread; 692 switch_to_thread (ptid); 693 694 expression_up expr = parse_expression ("(int) errno"); 695 struct value *val = evaluate_expression (expr.get ()); 696 697 if (tdb_testinfo->log_progress) 698 { 699 struct value_print_options opts; 700 701 get_user_print_options (&opts); 702 LOG (" = "); 703 value_print (val, gdb_stdlog, &opts); 704 } 705 } 706 707 LOG (" ... OK\n"); 708 709#undef LOG 710#undef CHECK_1 711#undef CHECK 712#undef CALL_UNCHECKED 713#undef CHECK_CALL 714#undef CALL 715 716 return 0; 717} 718 719/* Run integrity checks on the dlopen()ed libthread_db described by 720 INFO. Returns true on success, displays a warning and returns 721 false on failure. Logs progress messages to gdb_stdlog during 722 the test if LOG_PROGRESS is true. */ 723 724static bool 725check_thread_db (struct thread_db_info *info, bool log_progress) 726{ 727 bool test_passed = true; 728 729 if (log_progress) 730 debug_printf (_("Running libthread_db integrity checks:\n")); 731 732 /* GDB avoids using td_ta_thr_iter wherever possible (see comment 733 in try_thread_db_load_1 below) so in order to test it we may 734 have to locate it ourselves. */ 735 td_ta_thr_iter_ftype *td_ta_thr_iter_p = info->td_ta_thr_iter_p; 736 if (td_ta_thr_iter_p == NULL) 737 { 738 void *thr_iter = verbose_dlsym (info->handle, "td_ta_thr_iter"); 739 if (thr_iter == NULL) 740 return 0; 741 742 td_ta_thr_iter_p = (td_ta_thr_iter_ftype *) thr_iter; 743 } 744 745 /* Set up the test state we share with the callback. */ 746 gdb_assert (tdb_testinfo == NULL); 747 struct check_thread_db_info tdb_testinfo_buf; 748 tdb_testinfo = &tdb_testinfo_buf; 749 750 memset (tdb_testinfo, 0, sizeof (struct check_thread_db_info)); 751 tdb_testinfo->info = info; 752 tdb_testinfo->log_progress = log_progress; 753 754 /* td_ta_thr_iter shouldn't be used on running processes. Note that 755 it's possible the inferior will stop midway through modifying one 756 of its thread lists, in which case the check will spuriously 757 fail. */ 758 linux_stop_and_wait_all_lwps (); 759 760 TRY 761 { 762 td_err_e err = td_ta_thr_iter_p (info->thread_agent, 763 check_thread_db_callback, 764 tdb_testinfo, 765 TD_THR_ANY_STATE, 766 TD_THR_LOWEST_PRIORITY, 767 TD_SIGNO_MASK, 768 TD_THR_ANY_USER_FLAGS); 769 770 if (err != TD_OK) 771 error (_("td_ta_thr_iter failed: %s"), thread_db_err_str (err)); 772 773 if (!tdb_testinfo->threads_seen) 774 error (_("no threads seen")); 775 } 776 CATCH (except, RETURN_MASK_ERROR) 777 { 778 if (warning_pre_print) 779 fputs_unfiltered (warning_pre_print, gdb_stderr); 780 781 exception_fprintf (gdb_stderr, except, 782 _("libthread_db integrity checks failed: ")); 783 784 test_passed = false; 785 } 786 END_CATCH 787 788 if (test_passed && log_progress) 789 debug_printf (_("libthread_db integrity checks passed.\n")); 790 791 tdb_testinfo = NULL; 792 793 linux_unstop_all_lwps (); 794 795 return test_passed; 796} 797 798/* Attempt to initialize dlopen()ed libthread_db, described by INFO. 799 Return 1 on success. 800 Failure could happen if libthread_db does not have symbols we expect, 801 or when it refuses to work with the current inferior (e.g. due to 802 version mismatch between libthread_db and libpthread). */ 803 804static int 805try_thread_db_load_1 (struct thread_db_info *info) 806{ 807 td_err_e err; 808 809 /* Initialize pointers to the dynamic library functions we will use. 810 Essential functions first. */ 811 812#define TDB_VERBOSE_DLSYM(info, func) \ 813 info->func ## _p = (func ## _ftype *) verbose_dlsym (info->handle, #func) 814 815#define TDB_DLSYM(info, func) \ 816 info->func ## _p = (func ## _ftype *) dlsym (info->handle, #func) 817 818#define CHK(a) \ 819 do \ 820 { \ 821 if ((a) == NULL) \ 822 return 0; \ 823 } while (0) 824 825 CHK (TDB_VERBOSE_DLSYM (info, td_init)); 826 827 err = info->td_init_p (); 828 if (err != TD_OK) 829 { 830 warning (_("Cannot initialize libthread_db: %s"), 831 thread_db_err_str (err)); 832 return 0; 833 } 834 835 CHK (TDB_VERBOSE_DLSYM (info, td_ta_new)); 836 837 /* Initialize the structure that identifies the child process. */ 838 info->proc_handle.thread = inferior_thread (); 839 840 /* Now attempt to open a connection to the thread library. */ 841 err = info->td_ta_new_p (&info->proc_handle, &info->thread_agent); 842 if (err != TD_OK) 843 { 844 if (libthread_db_debug) 845 fprintf_unfiltered (gdb_stdlog, _("td_ta_new failed: %s\n"), 846 thread_db_err_str (err)); 847 else 848 switch (err) 849 { 850 case TD_NOLIBTHREAD: 851#ifdef THREAD_DB_HAS_TD_VERSION 852 case TD_VERSION: 853#endif 854 /* The errors above are not unexpected and silently ignored: 855 they just mean we haven't found correct version of 856 libthread_db yet. */ 857 break; 858 default: 859 warning (_("td_ta_new failed: %s"), thread_db_err_str (err)); 860 } 861 return 0; 862 } 863 864 /* These are essential. */ 865 CHK (TDB_VERBOSE_DLSYM (info, td_ta_map_lwp2thr)); 866 CHK (TDB_VERBOSE_DLSYM (info, td_thr_get_info)); 867 868 /* These are not essential. */ 869 TDB_DLSYM (info, td_thr_tls_get_addr); 870 TDB_DLSYM (info, td_thr_tlsbase); 871 TDB_DLSYM (info, td_ta_delete); 872 873 /* It's best to avoid td_ta_thr_iter if possible. That walks data 874 structures in the inferior's address space that may be corrupted, 875 or, if the target is running, may change while we walk them. If 876 there's execution (and /proc is mounted), then we're already 877 attached to all LWPs. Use thread_from_lwp, which uses 878 td_ta_map_lwp2thr instead, which does not walk the thread list. 879 880 td_ta_map_lwp2thr uses ps_get_thread_area, but we can't use that 881 currently on core targets, as it uses ptrace directly. */ 882 if (target_has_execution 883 && linux_proc_task_list_dir_exists (inferior_ptid.pid ())) 884 info->td_ta_thr_iter_p = NULL; 885 else 886 CHK (TDB_VERBOSE_DLSYM (info, td_ta_thr_iter)); 887 888#undef TDB_VERBOSE_DLSYM 889#undef TDB_DLSYM 890#undef CHK 891 892 /* Run integrity checks if requested. */ 893 if (check_thread_db_on_load) 894 { 895 if (!check_thread_db (info, libthread_db_debug)) 896 return 0; 897 } 898 899 if (info->td_ta_thr_iter_p == NULL) 900 { 901 struct lwp_info *lp; 902 int pid = inferior_ptid.pid (); 903 thread_info *curr_thread = inferior_thread (); 904 905 linux_stop_and_wait_all_lwps (); 906 907 ALL_LWPS (lp) 908 if (lp->ptid.pid () == pid) 909 thread_from_lwp (curr_thread, lp->ptid); 910 911 linux_unstop_all_lwps (); 912 } 913 else if (thread_db_find_new_threads_silently (inferior_thread ()) != 0) 914 { 915 /* Even if libthread_db initializes, if the thread list is 916 corrupted, we'd not manage to list any threads. Better reject this 917 thread_db, and fall back to at least listing LWPs. */ 918 return 0; 919 } 920 921 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n")); 922 923 if (*libthread_db_search_path || libthread_db_debug) 924 { 925 struct ui_file *file; 926 const char *library; 927 928 library = dladdr_to_soname ((const void *) *info->td_ta_new_p); 929 if (library == NULL) 930 library = LIBTHREAD_DB_SO; 931 932 /* If we'd print this to gdb_stdout when debug output is 933 disabled, still print it to gdb_stdout if debug output is 934 enabled. User visible output should not depend on debug 935 settings. */ 936 file = *libthread_db_search_path != '\0' ? gdb_stdout : gdb_stdlog; 937 fprintf_unfiltered (file, _("Using host libthread_db library \"%s\".\n"), 938 library); 939 } 940 941 /* The thread library was detected. Activate the thread_db target 942 if this is the first process using it. */ 943 if (thread_db_list->next == NULL) 944 push_target (&the_thread_db_target); 945 946 return 1; 947} 948 949/* Attempt to use LIBRARY as libthread_db. LIBRARY could be absolute, 950 relative, or just LIBTHREAD_DB. */ 951 952static int 953try_thread_db_load (const char *library, int check_auto_load_safe) 954{ 955 void *handle; 956 struct thread_db_info *info; 957 958 if (libthread_db_debug) 959 fprintf_unfiltered (gdb_stdlog, 960 _("Trying host libthread_db library: %s.\n"), 961 library); 962 963 if (check_auto_load_safe) 964 { 965 if (access (library, R_OK) != 0) 966 { 967 /* Do not print warnings by file_is_auto_load_safe if the library does 968 not exist at this place. */ 969 if (libthread_db_debug) 970 fprintf_unfiltered (gdb_stdlog, _("open failed: %s.\n"), 971 safe_strerror (errno)); 972 return 0; 973 } 974 975 if (!file_is_auto_load_safe (library, _("auto-load: Loading libthread-db " 976 "library \"%s\" from explicit " 977 "directory.\n"), 978 library)) 979 return 0; 980 } 981 982 handle = dlopen (library, RTLD_NOW); 983 if (handle == NULL) 984 { 985 if (libthread_db_debug) 986 fprintf_unfiltered (gdb_stdlog, _("dlopen failed: %s.\n"), dlerror ()); 987 return 0; 988 } 989 990 if (libthread_db_debug && strchr (library, '/') == NULL) 991 { 992 void *td_init; 993 994 td_init = dlsym (handle, "td_init"); 995 if (td_init != NULL) 996 { 997 const char *const libpath = dladdr_to_soname (td_init); 998 999 if (libpath != NULL) 1000 fprintf_unfiltered (gdb_stdlog, _("Host %s resolved to: %s.\n"), 1001 library, libpath); 1002 } 1003 } 1004 1005 info = add_thread_db_info (handle); 1006 1007 /* Do not save system library name, that one is always trusted. */ 1008 if (strchr (library, '/') != NULL) 1009 info->filename = gdb_realpath (library).release (); 1010 1011 if (try_thread_db_load_1 (info)) 1012 return 1; 1013 1014 /* This library "refused" to work on current inferior. */ 1015 delete_thread_db_info (inferior_ptid.pid ()); 1016 return 0; 1017} 1018 1019/* Subroutine of try_thread_db_load_from_pdir to simplify it. 1020 Try loading libthread_db in directory(OBJ)/SUBDIR. 1021 SUBDIR may be NULL. It may also be something like "../lib64". 1022 The result is true for success. */ 1023 1024static int 1025try_thread_db_load_from_pdir_1 (struct objfile *obj, const char *subdir) 1026{ 1027 const char *obj_name = objfile_name (obj); 1028 1029 if (obj_name[0] != '/') 1030 { 1031 warning (_("Expected absolute pathname for libpthread in the" 1032 " inferior, but got %s."), obj_name); 1033 return 0; 1034 } 1035 1036 std::string path = obj_name; 1037 size_t cp = path.rfind ('/'); 1038 /* This should at minimum hit the first character. */ 1039 gdb_assert (cp != std::string::npos); 1040 path.resize (cp + 1); 1041 if (subdir != NULL) 1042 path = path + subdir + "/"; 1043 path += LIBTHREAD_DB_SO; 1044 1045 return try_thread_db_load (path.c_str (), 1); 1046} 1047 1048/* Handle $pdir in libthread-db-search-path. 1049 Look for libthread_db in directory(libpthread)/SUBDIR. 1050 SUBDIR may be NULL. It may also be something like "../lib64". 1051 The result is true for success. */ 1052 1053static int 1054try_thread_db_load_from_pdir (const char *subdir) 1055{ 1056 if (!auto_load_thread_db) 1057 return 0; 1058 1059 for (objfile *obj : current_program_space->objfiles ()) 1060 if (libpthread_name_p (objfile_name (obj))) 1061 { 1062 if (try_thread_db_load_from_pdir_1 (obj, subdir)) 1063 return 1; 1064 1065 /* We may have found the separate-debug-info version of 1066 libpthread, and it may live in a directory without a matching 1067 libthread_db. */ 1068 if (obj->separate_debug_objfile_backlink != NULL) 1069 return try_thread_db_load_from_pdir_1 (obj->separate_debug_objfile_backlink, 1070 subdir); 1071 1072 return 0; 1073 } 1074 1075 return 0; 1076} 1077 1078/* Handle $sdir in libthread-db-search-path. 1079 Look for libthread_db in the system dirs, or wherever a plain 1080 dlopen(file_without_path) will look. 1081 The result is true for success. */ 1082 1083static int 1084try_thread_db_load_from_sdir (void) 1085{ 1086 return try_thread_db_load (LIBTHREAD_DB_SO, 0); 1087} 1088 1089/* Try to load libthread_db from directory DIR of length DIR_LEN. 1090 The result is true for success. */ 1091 1092static int 1093try_thread_db_load_from_dir (const char *dir, size_t dir_len) 1094{ 1095 if (!auto_load_thread_db) 1096 return 0; 1097 1098 std::string path = std::string (dir, dir_len) + "/" + LIBTHREAD_DB_SO; 1099 1100 return try_thread_db_load (path.c_str (), 1); 1101} 1102 1103/* Search libthread_db_search_path for libthread_db which "agrees" 1104 to work on current inferior. 1105 The result is true for success. */ 1106 1107static int 1108thread_db_load_search (void) 1109{ 1110 int rc = 0; 1111 1112 std::vector<gdb::unique_xmalloc_ptr<char>> dir_vec 1113 = dirnames_to_char_ptr_vec (libthread_db_search_path); 1114 1115 for (const gdb::unique_xmalloc_ptr<char> &this_dir_up : dir_vec) 1116 { 1117 const char *this_dir = this_dir_up.get (); 1118 const int pdir_len = sizeof ("$pdir") - 1; 1119 size_t this_dir_len; 1120 1121 this_dir_len = strlen (this_dir); 1122 1123 if (strncmp (this_dir, "$pdir", pdir_len) == 0 1124 && (this_dir[pdir_len] == '\0' 1125 || this_dir[pdir_len] == '/')) 1126 { 1127 const char *subdir = NULL; 1128 1129 std::string subdir_holder; 1130 if (this_dir[pdir_len] == '/') 1131 { 1132 subdir_holder = std::string (this_dir + pdir_len + 1); 1133 subdir = subdir_holder.c_str (); 1134 } 1135 rc = try_thread_db_load_from_pdir (subdir); 1136 if (rc) 1137 break; 1138 } 1139 else if (strcmp (this_dir, "$sdir") == 0) 1140 { 1141 if (try_thread_db_load_from_sdir ()) 1142 { 1143 rc = 1; 1144 break; 1145 } 1146 } 1147 else 1148 { 1149 if (try_thread_db_load_from_dir (this_dir, this_dir_len)) 1150 { 1151 rc = 1; 1152 break; 1153 } 1154 } 1155 } 1156 1157 if (libthread_db_debug) 1158 fprintf_unfiltered (gdb_stdlog, 1159 _("thread_db_load_search returning %d\n"), rc); 1160 return rc; 1161} 1162 1163/* Return non-zero if the inferior has a libpthread. */ 1164 1165static int 1166has_libpthread (void) 1167{ 1168 for (objfile *obj : current_program_space->objfiles ()) 1169 if (libpthread_name_p (objfile_name (obj))) 1170 return 1; 1171 1172 return 0; 1173} 1174 1175/* Attempt to load and initialize libthread_db. 1176 Return 1 on success. */ 1177 1178static int 1179thread_db_load (void) 1180{ 1181 struct thread_db_info *info; 1182 1183 info = get_thread_db_info (inferior_ptid.pid ()); 1184 1185 if (info != NULL) 1186 return 1; 1187 1188 /* Don't attempt to use thread_db on executables not running 1189 yet. */ 1190 if (!target_has_registers) 1191 return 0; 1192 1193 /* Don't attempt to use thread_db for remote targets. */ 1194 if (!(target_can_run () || core_bfd)) 1195 return 0; 1196 1197 if (thread_db_load_search ()) 1198 return 1; 1199 1200 /* We couldn't find a libthread_db. 1201 If the inferior has a libpthread warn the user. */ 1202 if (has_libpthread ()) 1203 { 1204 warning (_("Unable to find libthread_db matching inferior's thread" 1205 " library, thread debugging will not be available.")); 1206 return 0; 1207 } 1208 1209 /* Either this executable isn't using libpthread at all, or it is 1210 statically linked. Since we can't easily distinguish these two cases, 1211 no warning is issued. */ 1212 return 0; 1213} 1214 1215static void 1216check_thread_signals (void) 1217{ 1218 if (!thread_signals) 1219 { 1220 sigset_t mask; 1221 int i; 1222 1223 lin_thread_get_thread_signals (&mask); 1224 sigemptyset (&thread_stop_set); 1225 sigemptyset (&thread_print_set); 1226 1227 for (i = 1; i < NSIG; i++) 1228 { 1229 if (sigismember (&mask, i)) 1230 { 1231 if (signal_stop_update (gdb_signal_from_host (i), 0)) 1232 sigaddset (&thread_stop_set, i); 1233 if (signal_print_update (gdb_signal_from_host (i), 0)) 1234 sigaddset (&thread_print_set, i); 1235 thread_signals = 1; 1236 } 1237 } 1238 } 1239} 1240 1241/* Check whether thread_db is usable. This function is called when 1242 an inferior is created (or otherwise acquired, e.g. attached to) 1243 and when new shared libraries are loaded into a running process. */ 1244 1245void 1246check_for_thread_db (void) 1247{ 1248 /* Do nothing if we couldn't load libthread_db.so.1. */ 1249 if (!thread_db_load ()) 1250 return; 1251} 1252 1253/* This function is called via the new_objfile observer. */ 1254 1255static void 1256thread_db_new_objfile (struct objfile *objfile) 1257{ 1258 /* This observer must always be called with inferior_ptid set 1259 correctly. */ 1260 1261 if (objfile != NULL 1262 /* libpthread with separate debug info has its debug info file already 1263 loaded (and notified without successful thread_db initialization) 1264 the time gdb::observers::new_objfile.notify is called for the library itself. 1265 Static executables have their separate debug info loaded already 1266 before the inferior has started. */ 1267 && objfile->separate_debug_objfile_backlink == NULL 1268 /* Only check for thread_db if we loaded libpthread, 1269 or if this is the main symbol file. 1270 We need to check OBJF_MAINLINE to handle the case of debugging 1271 a statically linked executable AND the symbol file is specified AFTER 1272 the exec file is loaded (e.g., gdb -c core ; file foo). 1273 For dynamically linked executables, libpthread can be near the end 1274 of the list of shared libraries to load, and in an app of several 1275 thousand shared libraries, this can otherwise be painful. */ 1276 && ((objfile->flags & OBJF_MAINLINE) != 0 1277 || libpthread_name_p (objfile_name (objfile)))) 1278 check_for_thread_db (); 1279} 1280 1281static void 1282check_pid_namespace_match (void) 1283{ 1284 /* Check is only relevant for local targets targets. */ 1285 if (target_can_run ()) 1286 { 1287 /* If the child is in a different PID namespace, its idea of its 1288 PID will differ from our idea of its PID. When we scan the 1289 child's thread list, we'll mistakenly think it has no threads 1290 since the thread PID fields won't match the PID we give to 1291 libthread_db. */ 1292 if (!linux_ns_same (inferior_ptid.pid (), LINUX_NS_PID)) 1293 { 1294 warning (_ ("Target and debugger are in different PID " 1295 "namespaces; thread lists and other data are " 1296 "likely unreliable. " 1297 "Connect to gdbserver inside the container.")); 1298 } 1299 } 1300} 1301 1302/* This function is called via the inferior_created observer. 1303 This handles the case of debugging statically linked executables. */ 1304 1305static void 1306thread_db_inferior_created (struct target_ops *target, int from_tty) 1307{ 1308 check_pid_namespace_match (); 1309 check_for_thread_db (); 1310} 1311 1312/* Update the thread's state (what's displayed in "info threads"), 1313 from libthread_db thread state information. */ 1314 1315static void 1316update_thread_state (thread_db_thread_info *priv, 1317 const td_thrinfo_t *ti_p) 1318{ 1319 priv->dying = (ti_p->ti_state == TD_THR_UNKNOWN 1320 || ti_p->ti_state == TD_THR_ZOMBIE); 1321} 1322 1323/* Record a new thread in GDB's thread list. Creates the thread's 1324 private info. If TP is NULL or TP is marked as having exited, 1325 creates a new thread. Otherwise, uses TP. */ 1326 1327static struct thread_info * 1328record_thread (struct thread_db_info *info, 1329 struct thread_info *tp, 1330 ptid_t ptid, const td_thrhandle_t *th_p, 1331 const td_thrinfo_t *ti_p) 1332{ 1333 /* A thread ID of zero may mean the thread library has not 1334 initialized yet. Leave private == NULL until the thread library 1335 has initialized. */ 1336 if (ti_p->ti_tid == 0) 1337 return tp; 1338 1339 /* Construct the thread's private data. */ 1340 thread_db_thread_info *priv = new thread_db_thread_info; 1341 1342 priv->th = *th_p; 1343 priv->tid = ti_p->ti_tid; 1344 update_thread_state (priv, ti_p); 1345 1346 /* Add the thread to GDB's thread list. If we already know about a 1347 thread with this PTID, but it's marked exited, then the kernel 1348 reused the tid of an old thread. */ 1349 if (tp == NULL || tp->state == THREAD_EXITED) 1350 tp = add_thread_with_info (ptid, priv); 1351 else 1352 tp->priv.reset (priv); 1353 1354 if (target_has_execution) 1355 check_thread_signals (); 1356 1357 return tp; 1358} 1359 1360void 1361thread_db_target::detach (inferior *inf, int from_tty) 1362{ 1363 delete_thread_db_info (inf->pid); 1364 1365 beneath ()->detach (inf, from_tty); 1366 1367 /* NOTE: From this point on, inferior_ptid is null_ptid. */ 1368 1369 /* If there are no more processes using libpthread, detach the 1370 thread_db target ops. */ 1371 if (!thread_db_list) 1372 unpush_target (this); 1373} 1374 1375ptid_t 1376thread_db_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus, 1377 int options) 1378{ 1379 struct thread_db_info *info; 1380 1381 ptid = beneath ()->wait (ptid, ourstatus, options); 1382 1383 switch (ourstatus->kind) 1384 { 1385 case TARGET_WAITKIND_IGNORE: 1386 case TARGET_WAITKIND_EXITED: 1387 case TARGET_WAITKIND_THREAD_EXITED: 1388 case TARGET_WAITKIND_SIGNALLED: 1389 return ptid; 1390 } 1391 1392 info = get_thread_db_info (ptid.pid ()); 1393 1394 /* If this process isn't using thread_db, we're done. */ 1395 if (info == NULL) 1396 return ptid; 1397 1398 if (ourstatus->kind == TARGET_WAITKIND_EXECD) 1399 { 1400 /* New image, it may or may not end up using thread_db. Assume 1401 not unless we find otherwise. */ 1402 delete_thread_db_info (ptid.pid ()); 1403 if (!thread_db_list) 1404 unpush_target (&the_thread_db_target); 1405 1406 return ptid; 1407 } 1408 1409 /* Fill in the thread's user-level thread id and status. */ 1410 thread_from_lwp (find_thread_ptid (ptid), ptid); 1411 1412 return ptid; 1413} 1414 1415void 1416thread_db_target::mourn_inferior () 1417{ 1418 delete_thread_db_info (inferior_ptid.pid ()); 1419 1420 beneath ()->mourn_inferior (); 1421 1422 /* Detach thread_db target ops. */ 1423 if (!thread_db_list) 1424 unpush_target (&the_thread_db_target); 1425} 1426 1427struct callback_data 1428{ 1429 struct thread_db_info *info; 1430 int new_threads; 1431}; 1432 1433static int 1434find_new_threads_callback (const td_thrhandle_t *th_p, void *data) 1435{ 1436 td_thrinfo_t ti; 1437 td_err_e err; 1438 struct thread_info *tp; 1439 struct callback_data *cb_data = (struct callback_data *) data; 1440 struct thread_db_info *info = cb_data->info; 1441 1442 err = info->td_thr_get_info_p (th_p, &ti); 1443 if (err != TD_OK) 1444 error (_("find_new_threads_callback: cannot get thread info: %s"), 1445 thread_db_err_str (err)); 1446 1447 if (ti.ti_lid == -1) 1448 { 1449 /* A thread with kernel thread ID -1 is either a thread that 1450 exited and was joined, or a thread that is being created but 1451 hasn't started yet, and that is reusing the tcb/stack of a 1452 thread that previously exited and was joined. (glibc marks 1453 terminated and joined threads with kernel thread ID -1. See 1454 glibc PR17707. */ 1455 if (libthread_db_debug) 1456 fprintf_unfiltered (gdb_stdlog, 1457 "thread_db: skipping exited and " 1458 "joined thread (0x%lx)\n", 1459 (unsigned long) ti.ti_tid); 1460 return 0; 1461 } 1462 1463 if (ti.ti_tid == 0) 1464 { 1465 /* A thread ID of zero means that this is the main thread, but 1466 glibc has not yet initialized thread-local storage and the 1467 pthread library. We do not know what the thread's TID will 1468 be yet. */ 1469 1470 /* In that case, we're not stopped in a fork syscall and don't 1471 need this glibc bug workaround. */ 1472 info->need_stale_parent_threads_check = 0; 1473 1474 return 0; 1475 } 1476 1477 /* Ignore stale parent threads, caused by glibc/BZ5983. This is a 1478 bit expensive, as it needs to open /proc/pid/status, so try to 1479 avoid doing the work if we know we don't have to. */ 1480 if (info->need_stale_parent_threads_check) 1481 { 1482 int tgid = linux_proc_get_tgid (ti.ti_lid); 1483 1484 if (tgid != -1 && tgid != info->pid) 1485 return 0; 1486 } 1487 1488 ptid_t ptid (info->pid, ti.ti_lid); 1489 tp = find_thread_ptid (ptid); 1490 if (tp == NULL || tp->priv == NULL) 1491 record_thread (info, tp, ptid, th_p, &ti); 1492 1493 return 0; 1494} 1495 1496/* Helper for thread_db_find_new_threads_2. 1497 Returns number of new threads found. */ 1498 1499static int 1500find_new_threads_once (struct thread_db_info *info, int iteration, 1501 td_err_e *errp) 1502{ 1503 struct callback_data data; 1504 td_err_e err = TD_ERR; 1505 1506 data.info = info; 1507 data.new_threads = 0; 1508 1509 /* See comment in thread_db_update_thread_list. */ 1510 gdb_assert (info->td_ta_thr_iter_p != NULL); 1511 1512 TRY 1513 { 1514 /* Iterate over all user-space threads to discover new threads. */ 1515 err = info->td_ta_thr_iter_p (info->thread_agent, 1516 find_new_threads_callback, 1517 &data, 1518 TD_THR_ANY_STATE, 1519 TD_THR_LOWEST_PRIORITY, 1520 TD_SIGNO_MASK, 1521 TD_THR_ANY_USER_FLAGS); 1522 } 1523 CATCH (except, RETURN_MASK_ERROR) 1524 { 1525 if (libthread_db_debug) 1526 { 1527 exception_fprintf (gdb_stdlog, except, 1528 "Warning: find_new_threads_once: "); 1529 } 1530 } 1531 END_CATCH 1532 1533 if (libthread_db_debug) 1534 { 1535 fprintf_unfiltered (gdb_stdlog, 1536 _("Found %d new threads in iteration %d.\n"), 1537 data.new_threads, iteration); 1538 } 1539 1540 if (errp != NULL) 1541 *errp = err; 1542 1543 return data.new_threads; 1544} 1545 1546/* Search for new threads, accessing memory through stopped thread 1547 PTID. If UNTIL_NO_NEW is true, repeat searching until several 1548 searches in a row do not discover any new threads. */ 1549 1550static void 1551thread_db_find_new_threads_2 (thread_info *stopped, bool until_no_new) 1552{ 1553 td_err_e err = TD_OK; 1554 struct thread_db_info *info; 1555 int i, loop; 1556 1557 info = get_thread_db_info (stopped->ptid.pid ()); 1558 1559 /* Access an lwp we know is stopped. */ 1560 info->proc_handle.thread = stopped; 1561 1562 if (until_no_new) 1563 { 1564 /* Require 4 successive iterations which do not find any new threads. 1565 The 4 is a heuristic: there is an inherent race here, and I have 1566 seen that 2 iterations in a row are not always sufficient to 1567 "capture" all threads. */ 1568 for (i = 0, loop = 0; loop < 4 && err == TD_OK; ++i, ++loop) 1569 if (find_new_threads_once (info, i, &err) != 0) 1570 { 1571 /* Found some new threads. Restart the loop from beginning. */ 1572 loop = -1; 1573 } 1574 } 1575 else 1576 find_new_threads_once (info, 0, &err); 1577 1578 if (err != TD_OK) 1579 error (_("Cannot find new threads: %s"), thread_db_err_str (err)); 1580} 1581 1582static void 1583thread_db_find_new_threads_1 (thread_info *stopped) 1584{ 1585 thread_db_find_new_threads_2 (stopped, 0); 1586} 1587 1588/* Implement the to_update_thread_list target method for this 1589 target. */ 1590 1591void 1592thread_db_target::update_thread_list () 1593{ 1594 struct thread_db_info *info; 1595 1596 prune_threads (); 1597 1598 for (inferior *inf : all_inferiors ()) 1599 { 1600 struct thread_info *thread; 1601 1602 if (inf->pid == 0) 1603 continue; 1604 1605 info = get_thread_db_info (inf->pid); 1606 if (info == NULL) 1607 continue; 1608 1609 thread = any_live_thread_of_inferior (inf); 1610 if (thread == NULL || thread->executing) 1611 continue; 1612 1613 /* It's best to avoid td_ta_thr_iter if possible. That walks 1614 data structures in the inferior's address space that may be 1615 corrupted, or, if the target is running, the list may change 1616 while we walk it. In the latter case, it's possible that a 1617 thread exits just at the exact time that causes GDB to get 1618 stuck in an infinite loop. To avoid pausing all threads 1619 whenever the core wants to refresh the thread list, we 1620 instead use thread_from_lwp immediately when we see an LWP 1621 stop. That uses thread_db entry points that do not walk 1622 libpthread's thread list, so should be safe, as well as more 1623 efficient. */ 1624 if (target_has_execution_1 (thread->ptid)) 1625 continue; 1626 1627 thread_db_find_new_threads_1 (thread); 1628 } 1629 1630 /* Give the beneath target a chance to do extra processing. */ 1631 this->beneath ()->update_thread_list (); 1632} 1633 1634const char * 1635thread_db_target::pid_to_str (ptid_t ptid) 1636{ 1637 struct thread_info *thread_info = find_thread_ptid (ptid); 1638 1639 if (thread_info != NULL && thread_info->priv != NULL) 1640 { 1641 static char buf[64]; 1642 thread_db_thread_info *priv = get_thread_db_thread_info (thread_info); 1643 1644 snprintf (buf, sizeof (buf), "Thread 0x%lx (LWP %ld)", 1645 (unsigned long) priv->tid, ptid.lwp ()); 1646 1647 return buf; 1648 } 1649 1650 return beneath ()->pid_to_str (ptid); 1651} 1652 1653/* Return a string describing the state of the thread specified by 1654 INFO. */ 1655 1656const char * 1657thread_db_target::extra_thread_info (thread_info *info) 1658{ 1659 if (info->priv == NULL) 1660 return NULL; 1661 1662 thread_db_thread_info *priv = get_thread_db_thread_info (info); 1663 1664 if (priv->dying) 1665 return "Exiting"; 1666 1667 return NULL; 1668} 1669 1670/* Return pointer to the thread_info struct which corresponds to 1671 THREAD_HANDLE (having length HANDLE_LEN). */ 1672 1673thread_info * 1674thread_db_target::thread_handle_to_thread_info (const gdb_byte *thread_handle, 1675 int handle_len, 1676 inferior *inf) 1677{ 1678 thread_t handle_tid; 1679 1680 /* Thread handle sizes must match in order to proceed. We don't use an 1681 assert here because the resulting internal error will cause GDB to 1682 exit. This isn't necessarily an internal error due to the possibility 1683 of garbage being passed as the thread handle via the python interface. */ 1684 if (handle_len != sizeof (handle_tid)) 1685 error (_("Thread handle size mismatch: %d vs %zu (from libthread_db)"), 1686 handle_len, sizeof (handle_tid)); 1687 1688 handle_tid = * (const thread_t *) thread_handle; 1689 1690 for (thread_info *tp : inf->non_exited_threads ()) 1691 { 1692 thread_db_thread_info *priv = get_thread_db_thread_info (tp); 1693 1694 if (priv != NULL && handle_tid == priv->tid) 1695 return tp; 1696 } 1697 1698 return NULL; 1699} 1700 1701/* Get the address of the thread local variable in load module LM which 1702 is stored at OFFSET within the thread local storage for thread PTID. */ 1703 1704CORE_ADDR 1705thread_db_target::get_thread_local_address (ptid_t ptid, 1706 CORE_ADDR lm, 1707 CORE_ADDR offset) 1708{ 1709 struct thread_info *thread_info; 1710 1711 /* Find the matching thread. */ 1712 thread_info = find_thread_ptid (ptid); 1713 1714 /* We may not have discovered the thread yet. */ 1715 if (thread_info != NULL && thread_info->priv == NULL) 1716 thread_info = thread_from_lwp (thread_info, ptid); 1717 1718 if (thread_info != NULL && thread_info->priv != NULL) 1719 { 1720 td_err_e err; 1721 psaddr_t address; 1722 thread_db_info *info = get_thread_db_info (ptid.pid ()); 1723 thread_db_thread_info *priv = get_thread_db_thread_info (thread_info); 1724 1725 /* Finally, get the address of the variable. */ 1726 if (lm != 0) 1727 { 1728 /* glibc doesn't provide the needed interface. */ 1729 if (!info->td_thr_tls_get_addr_p) 1730 throw_error (TLS_NO_LIBRARY_SUPPORT_ERROR, 1731 _("No TLS library support")); 1732 1733 /* Note the cast through uintptr_t: this interface only works if 1734 a target address fits in a psaddr_t, which is a host pointer. 1735 So a 32-bit debugger can not access 64-bit TLS through this. */ 1736 err = info->td_thr_tls_get_addr_p (&priv->th, 1737 (psaddr_t)(uintptr_t) lm, 1738 offset, &address); 1739 } 1740 else 1741 { 1742 /* If glibc doesn't provide the needed interface throw an error 1743 that LM is zero - normally cases it should not be. */ 1744 if (!info->td_thr_tlsbase_p) 1745 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR, 1746 _("TLS load module not found")); 1747 1748 /* This code path handles the case of -static -pthread executables: 1749 https://sourceware.org/ml/libc-help/2014-03/msg00024.html 1750 For older GNU libc r_debug.r_map is NULL. For GNU libc after 1751 PR libc/16831 due to GDB PR threads/16954 LOAD_MODULE is also NULL. 1752 The constant number 1 depends on GNU __libc_setup_tls 1753 initialization of l_tls_modid to 1. */ 1754 err = info->td_thr_tlsbase_p (&priv->th, 1, &address); 1755 address = (char *) address + offset; 1756 } 1757 1758#ifdef THREAD_DB_HAS_TD_NOTALLOC 1759 /* The memory hasn't been allocated, yet. */ 1760 if (err == TD_NOTALLOC) 1761 /* Now, if libthread_db provided the initialization image's 1762 address, we *could* try to build a non-lvalue value from 1763 the initialization image. */ 1764 throw_error (TLS_NOT_ALLOCATED_YET_ERROR, 1765 _("TLS not allocated yet")); 1766#endif 1767 1768 /* Something else went wrong. */ 1769 if (err != TD_OK) 1770 throw_error (TLS_GENERIC_ERROR, 1771 (("%s")), thread_db_err_str (err)); 1772 1773 /* Cast assuming host == target. Joy. */ 1774 /* Do proper sign extension for the target. */ 1775 gdb_assert (exec_bfd); 1776 return (bfd_get_sign_extend_vma (exec_bfd) > 0 1777 ? (CORE_ADDR) (intptr_t) address 1778 : (CORE_ADDR) (uintptr_t) address); 1779 } 1780 1781 return beneath ()->get_thread_local_address (ptid, lm, offset); 1782} 1783 1784/* Implement the to_get_ada_task_ptid target method for this target. */ 1785 1786ptid_t 1787thread_db_target::get_ada_task_ptid (long lwp, long thread) 1788{ 1789 /* NPTL uses a 1:1 model, so the LWP id suffices. */ 1790 return ptid_t (inferior_ptid.pid (), lwp, 0); 1791} 1792 1793void 1794thread_db_target::resume (ptid_t ptid, int step, enum gdb_signal signo) 1795{ 1796 struct thread_db_info *info; 1797 1798 if (ptid == minus_one_ptid) 1799 info = get_thread_db_info (inferior_ptid.pid ()); 1800 else 1801 info = get_thread_db_info (ptid.pid ()); 1802 1803 /* This workaround is only needed for child fork lwps stopped in a 1804 PTRACE_O_TRACEFORK event. When the inferior is resumed, the 1805 workaround can be disabled. */ 1806 if (info) 1807 info->need_stale_parent_threads_check = 0; 1808 1809 beneath ()->resume (ptid, step, signo); 1810} 1811 1812/* std::sort helper function for info_auto_load_libthread_db, sort the 1813 thread_db_info pointers primarily by their FILENAME and secondarily by their 1814 PID, both in ascending order. */ 1815 1816static bool 1817info_auto_load_libthread_db_compare (const struct thread_db_info *a, 1818 const struct thread_db_info *b) 1819{ 1820 int retval; 1821 1822 retval = strcmp (a->filename, b->filename); 1823 if (retval) 1824 return retval < 0; 1825 1826 return a->pid < b->pid; 1827} 1828 1829/* Implement 'info auto-load libthread-db'. */ 1830 1831static void 1832info_auto_load_libthread_db (const char *args, int from_tty) 1833{ 1834 struct ui_out *uiout = current_uiout; 1835 const char *cs = args ? args : ""; 1836 struct thread_db_info *info; 1837 unsigned unique_filenames; 1838 size_t max_filename_len, pids_len; 1839 int i; 1840 1841 cs = skip_spaces (cs); 1842 if (*cs) 1843 error (_("'info auto-load libthread-db' does not accept any parameters")); 1844 1845 std::vector<struct thread_db_info *> array; 1846 for (info = thread_db_list; info; info = info->next) 1847 if (info->filename != NULL) 1848 array.push_back (info); 1849 1850 /* Sort ARRAY by filenames and PIDs. */ 1851 std::sort (array.begin (), array.end (), 1852 info_auto_load_libthread_db_compare); 1853 1854 /* Calculate the number of unique filenames (rows) and the maximum string 1855 length of PIDs list for the unique filenames (columns). */ 1856 1857 unique_filenames = 0; 1858 max_filename_len = 0; 1859 pids_len = 0; 1860 for (i = 0; i < array.size (); i++) 1861 { 1862 int pid = array[i]->pid; 1863 size_t this_pid_len; 1864 1865 for (this_pid_len = 0; pid != 0; pid /= 10) 1866 this_pid_len++; 1867 1868 if (i == 0 || strcmp (array[i - 1]->filename, array[i]->filename) != 0) 1869 { 1870 unique_filenames++; 1871 max_filename_len = std::max (max_filename_len, 1872 strlen (array[i]->filename)); 1873 1874 if (i > 0) 1875 pids_len -= strlen (", "); 1876 pids_len = 0; 1877 } 1878 pids_len += this_pid_len + strlen (", "); 1879 } 1880 if (i) 1881 pids_len -= strlen (", "); 1882 1883 /* Table header shifted right by preceding "libthread-db: " would not match 1884 its columns. */ 1885 if (array.size () > 0 && args == auto_load_info_scripts_pattern_nl) 1886 uiout->text ("\n"); 1887 1888 { 1889 ui_out_emit_table table_emitter (uiout, 2, unique_filenames, 1890 "LinuxThreadDbTable"); 1891 1892 uiout->table_header (max_filename_len, ui_left, "filename", "Filename"); 1893 uiout->table_header (pids_len, ui_left, "PIDs", "Pids"); 1894 uiout->table_body (); 1895 1896 /* Note I is incremented inside the cycle, not at its end. */ 1897 for (i = 0; i < array.size ();) 1898 { 1899 ui_out_emit_tuple tuple_emitter (uiout, NULL); 1900 1901 info = array[i]; 1902 uiout->field_string ("filename", info->filename); 1903 1904 std::string pids; 1905 while (i < array.size () && strcmp (info->filename, 1906 array[i]->filename) == 0) 1907 { 1908 if (!pids.empty ()) 1909 pids += ", "; 1910 string_appendf (pids, "%u", array[i]->pid); 1911 i++; 1912 } 1913 1914 uiout->field_string ("pids", pids.c_str ()); 1915 1916 uiout->text ("\n"); 1917 } 1918 } 1919 1920 if (array.empty ()) 1921 uiout->message (_("No auto-loaded libthread-db.\n")); 1922} 1923 1924/* Implement 'maintenance check libthread-db'. */ 1925 1926static void 1927maintenance_check_libthread_db (const char *args, int from_tty) 1928{ 1929 int inferior_pid = inferior_ptid.pid (); 1930 struct thread_db_info *info; 1931 1932 if (inferior_pid == 0) 1933 error (_("No inferior running")); 1934 1935 info = get_thread_db_info (inferior_pid); 1936 if (info == NULL) 1937 error (_("No libthread_db loaded")); 1938 1939 check_thread_db (info, true); 1940} 1941 1942void 1943_initialize_thread_db (void) 1944{ 1945 /* Defer loading of libthread_db.so until inferior is running. 1946 This allows gdb to load correct libthread_db for a given 1947 executable -- there could be multiple versions of glibc, 1948 and until there is a running inferior, we can't tell which 1949 libthread_db is the correct one to load. */ 1950 1951 libthread_db_search_path = xstrdup (LIBTHREAD_DB_SEARCH_PATH); 1952 1953 add_setshow_optional_filename_cmd ("libthread-db-search-path", 1954 class_support, 1955 &libthread_db_search_path, _("\ 1956Set search path for libthread_db."), _("\ 1957Show the current search path or libthread_db."), _("\ 1958This path is used to search for libthread_db to be loaded into \ 1959gdb itself.\n\ 1960Its value is a colon (':') separate list of directories to search.\n\ 1961Setting the search path to an empty list resets it to its default value."), 1962 set_libthread_db_search_path, 1963 NULL, 1964 &setlist, &showlist); 1965 1966 add_setshow_zuinteger_cmd ("libthread-db", class_maintenance, 1967 &libthread_db_debug, _("\ 1968Set libthread-db debugging."), _("\ 1969Show libthread-db debugging."), _("\ 1970When non-zero, libthread-db debugging is enabled."), 1971 NULL, 1972 show_libthread_db_debug, 1973 &setdebuglist, &showdebuglist); 1974 1975 add_setshow_boolean_cmd ("libthread-db", class_support, 1976 &auto_load_thread_db, _("\ 1977Enable or disable auto-loading of inferior specific libthread_db."), _("\ 1978Show whether auto-loading inferior specific libthread_db is enabled."), _("\ 1979If enabled, libthread_db will be searched in 'set libthread-db-search-path'\n\ 1980locations to load libthread_db compatible with the inferior.\n\ 1981Standard system libthread_db still gets loaded even with this option off.\n\ 1982This options has security implications for untrusted inferiors."), 1983 NULL, show_auto_load_thread_db, 1984 auto_load_set_cmdlist_get (), 1985 auto_load_show_cmdlist_get ()); 1986 1987 add_cmd ("libthread-db", class_info, info_auto_load_libthread_db, 1988 _("Print the list of loaded inferior specific libthread_db.\n\ 1989Usage: info auto-load libthread-db"), 1990 auto_load_info_cmdlist_get ()); 1991 1992 add_cmd ("libthread-db", class_maintenance, 1993 maintenance_check_libthread_db, _("\ 1994Run integrity checks on the current inferior's libthread_db."), 1995 &maintenancechecklist); 1996 1997 add_setshow_boolean_cmd ("check-libthread-db", 1998 class_maintenance, 1999 &check_thread_db_on_load, _("\ 2000Set whether to check libthread_db at load time."), _("\ 2001Show whether to check libthread_db at load time."), _("\ 2002If enabled GDB will run integrity checks on inferior specific libthread_db\n\ 2003as they are loaded."), 2004 NULL, 2005 NULL, 2006 &maintenance_set_cmdlist, 2007 &maintenance_show_cmdlist); 2008 2009 /* Add ourselves to objfile event chain. */ 2010 gdb::observers::new_objfile.attach (thread_db_new_objfile); 2011 2012 /* Add ourselves to inferior_created event chain. 2013 This is needed to handle debugging statically linked programs where 2014 the new_objfile observer won't get called for libpthread. */ 2015 gdb::observers::inferior_created.attach (thread_db_inferior_created); 2016} 2017