GDBserver

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