GDB (xrefs)

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