1 /* Thread management interface, for the remote server for GDB.
2 Copyright (C) 2002-2015 Free Software Foundation, Inc.
4 Contributed by MontaVista Software.
6 This file is part of GDB.
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.
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.
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/>. */
23 #include "linux-low.h"
25 extern int debug_threads
;
27 static int thread_db_use_events
;
29 #include "gdb_proc_service.h"
30 #include "nat/gdb_thread_db.h"
32 #include "nat/linux-procfs.h"
34 #ifndef USE_LIBTHREAD_DB_DIRECTLY
42 /* Structure that identifies the child process for the
43 <proc_service.h> interface. */
44 struct ps_prochandle proc_handle
;
46 /* Connection to the libthread_db library. */
47 td_thragent_t
*thread_agent
;
49 /* If this flag has been set, we've already asked GDB for all
50 symbols we might need; assume symbol cache misses are
52 int all_symbols_looked_up
;
54 #ifndef USE_LIBTHREAD_DB_DIRECTLY
55 /* Handle of the libthread_db from dlopen. */
59 /* Thread creation event breakpoint. The code at this location in
60 the child process will be called by the pthread library whenever
61 a new thread is created. By setting a special breakpoint at this
62 location, GDB can detect when a new thread is created. We obtain
63 this location via the td_ta_event_addr call. Note that if the
64 running kernel supports tracing clones, then we don't need to use
65 (and in fact don't use) this magic thread event breakpoint to
66 learn about threads. */
67 struct breakpoint
*td_create_bp
;
69 /* Addresses of libthread_db functions. */
70 td_ta_new_ftype
*td_ta_new_p
;
71 td_ta_event_getmsg_ftype
* td_ta_event_getmsg_p
;
72 td_ta_set_event_ftype
*td_ta_set_event_p
;
73 td_ta_event_addr_ftype
*td_ta_event_addr_p
;
74 td_ta_map_lwp2thr_ftype
*td_ta_map_lwp2thr_p
;
75 td_thr_get_info_ftype
*td_thr_get_info_p
;
76 td_thr_event_enable_ftype
*td_thr_event_enable_p
;
77 td_ta_thr_iter_ftype
*td_ta_thr_iter_p
;
78 td_thr_tls_get_addr_ftype
*td_thr_tls_get_addr_p
;
79 td_thr_tlsbase_ftype
*td_thr_tlsbase_p
;
80 td_symbol_list_ftype
*td_symbol_list_p
;
83 static char *libthread_db_search_path
;
85 static int find_one_thread (ptid_t
);
86 static int find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
);
89 thread_db_err_str (td_err_e err
)
96 return "generic 'call succeeded'";
98 return "generic error";
100 return "no thread to satisfy query";
102 return "no sync handle to satisfy query";
104 return "no LWP to satisfy query";
106 return "invalid process handle";
108 return "invalid thread handle";
110 return "invalid synchronization handle";
112 return "invalid thread agent";
114 return "invalid key";
116 return "no event message for getmsg";
118 return "FPU register set not available";
120 return "application not linked with libthread";
122 return "requested event is not supported";
124 return "capability not available";
126 return "debugger service failed";
128 return "operation not applicable to";
130 return "no thread-specific data for this thread";
132 return "malloc failed";
134 return "only part of register set was written/read";
136 return "X register set not available for this thread";
137 #ifdef HAVE_TD_VERSION
139 return "version mismatch between libthread_db and libpthread";
142 xsnprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
149 thread_db_state_str (td_thr_state_e state
)
156 return "stopped by debugger";
165 case TD_THR_STOPPED_ASLEEP
:
166 return "stopped by debugger AND blocked";
168 xsnprintf (buf
, sizeof (buf
), "unknown thread_db state %d", state
);
175 thread_db_create_event (CORE_ADDR where
)
179 struct lwp_info
*lwp
;
180 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
182 gdb_assert (thread_db
->td_ta_event_getmsg_p
!= NULL
);
185 debug_printf ("Thread creation event.\n");
187 /* FIXME: This assumes we don't get another event.
188 In the LinuxThreads implementation, this is safe,
189 because all events come from the manager thread
190 (except for its own creation, of course). */
191 err
= thread_db
->td_ta_event_getmsg_p (thread_db
->thread_agent
, &msg
);
193 fprintf (stderr
, "thread getmsg err: %s\n",
194 thread_db_err_str (err
));
196 /* If we do not know about the main thread yet, this would be a good time to
197 find it. We need to do this to pick up the main thread before any newly
199 lwp
= get_thread_lwp (current_thread
);
200 if (lwp
->thread_known
== 0)
201 find_one_thread (current_thread
->entry
.id
);
203 /* msg.event == TD_EVENT_CREATE */
205 find_new_threads_callback (msg
.th_p
, NULL
);
211 thread_db_enable_reporting (void)
213 td_thr_events_t events
;
216 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
218 if (thread_db
->td_ta_set_event_p
== NULL
219 || thread_db
->td_ta_event_addr_p
== NULL
220 || thread_db
->td_ta_event_getmsg_p
== NULL
)
221 /* This libthread_db is missing required support. */
224 /* Set the process wide mask saying which events we're interested in. */
225 td_event_emptyset (&events
);
226 td_event_addset (&events
, TD_CREATE
);
228 err
= thread_db
->td_ta_set_event_p (thread_db
->thread_agent
, &events
);
231 warning ("Unable to set global thread event mask: %s",
232 thread_db_err_str (err
));
236 /* Get address for thread creation breakpoint. */
237 err
= thread_db
->td_ta_event_addr_p (thread_db
->thread_agent
, TD_CREATE
,
241 warning ("Unable to get location for thread creation breakpoint: %s",
242 thread_db_err_str (err
));
245 thread_db
->td_create_bp
246 = set_breakpoint_at ((CORE_ADDR
) (unsigned long) notify
.u
.bptaddr
,
247 thread_db_create_event
);
253 find_one_thread (ptid_t ptid
)
258 struct thread_info
*inferior
;
259 struct lwp_info
*lwp
;
260 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
261 int lwpid
= ptid_get_lwp (ptid
);
263 inferior
= (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
264 lwp
= get_thread_lwp (inferior
);
265 if (lwp
->thread_known
)
268 /* Get information about this thread. */
269 err
= thread_db
->td_ta_map_lwp2thr_p (thread_db
->thread_agent
, lwpid
, &th
);
271 error ("Cannot get thread handle for LWP %d: %s",
272 lwpid
, thread_db_err_str (err
));
274 err
= thread_db
->td_thr_get_info_p (&th
, &ti
);
276 error ("Cannot get thread info for LWP %d: %s",
277 lwpid
, thread_db_err_str (err
));
280 debug_printf ("Found thread %ld (LWP %d)\n",
281 ti
.ti_tid
, ti
.ti_lid
);
283 if (lwpid
!= ti
.ti_lid
)
285 warning ("PID mismatch! Expected %ld, got %ld",
286 (long) lwpid
, (long) ti
.ti_lid
);
290 if (thread_db_use_events
)
292 err
= thread_db
->td_thr_event_enable_p (&th
, 1);
294 error ("Cannot enable thread event reporting for %d: %s",
295 ti
.ti_lid
, thread_db_err_str (err
));
298 /* If the new thread ID is zero, a final thread ID will be available
299 later. Do not enable thread debugging yet. */
303 lwp
->thread_known
= 1;
309 /* Attach a thread. Return true on success. */
312 attach_thread (const td_thrhandle_t
*th_p
, td_thrinfo_t
*ti_p
)
314 struct process_info
*proc
= current_process ();
315 int pid
= pid_of (proc
);
316 ptid_t ptid
= ptid_build (pid
, ti_p
->ti_lid
, 0);
317 struct lwp_info
*lwp
;
321 debug_printf ("Attaching to thread %ld (LWP %d)\n",
322 ti_p
->ti_tid
, ti_p
->ti_lid
);
323 err
= linux_attach_lwp (ptid
);
326 warning ("Could not attach to thread %ld (LWP %d): %s\n",
327 ti_p
->ti_tid
, ti_p
->ti_lid
,
328 linux_ptrace_attach_fail_reason_string (ptid
, err
));
332 lwp
= find_lwp_pid (ptid
);
333 gdb_assert (lwp
!= NULL
);
334 lwp
->thread_known
= 1;
337 if (thread_db_use_events
)
340 struct thread_db
*thread_db
= proc
->priv
->thread_db
;
342 err
= thread_db
->td_thr_event_enable_p (th_p
, 1);
344 error ("Cannot enable thread event reporting for %d: %s",
345 ti_p
->ti_lid
, thread_db_err_str (err
));
351 /* Attach thread if we haven't seen it yet.
352 Increment *COUNTER if we have attached a new thread.
353 Return false on failure. */
356 maybe_attach_thread (const td_thrhandle_t
*th_p
, td_thrinfo_t
*ti_p
,
359 struct lwp_info
*lwp
;
361 lwp
= find_lwp_pid (pid_to_ptid (ti_p
->ti_lid
));
365 if (!attach_thread (th_p
, ti_p
))
375 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
379 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
381 err
= thread_db
->td_thr_get_info_p (th_p
, &ti
);
383 error ("Cannot get thread info: %s", thread_db_err_str (err
));
387 /* A thread with kernel thread ID -1 is either a thread that
388 exited and was joined, or a thread that is being created but
389 hasn't started yet, and that is reusing the tcb/stack of a
390 thread that previously exited and was joined. (glibc marks
391 terminated and joined threads with kernel thread ID -1. See
394 debug_printf ("thread_db: skipping exited and "
395 "joined thread (0x%lx)\n", ti
.ti_tid
);
399 /* Check for zombies. */
400 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
403 if (!maybe_attach_thread (th_p
, &ti
, (int *) data
))
405 /* Terminate iteration early: we might be looking at stale data in
406 the inferior. The thread_db_find_new_threads will retry. */
414 thread_db_find_new_threads (void)
417 ptid_t ptid
= current_ptid
;
418 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
421 /* This function is only called when we first initialize thread_db.
422 First locate the initial thread. If it is not ready for
423 debugging yet, then stop. */
424 if (find_one_thread (ptid
) == 0)
427 /* Require 4 successive iterations which do not find any new threads.
428 The 4 is a heuristic: there is an inherent race here, and I have
429 seen that 2 iterations in a row are not always sufficient to
430 "capture" all threads. */
431 for (loop
= 0, iteration
= 0; loop
< 4; ++loop
, ++iteration
)
433 int new_thread_count
= 0;
435 /* Iterate over all user-space threads to discover new threads. */
436 err
= thread_db
->td_ta_thr_iter_p (thread_db
->thread_agent
,
437 find_new_threads_callback
,
440 TD_THR_LOWEST_PRIORITY
,
441 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
443 debug_printf ("Found %d threads in iteration %d.\n",
444 new_thread_count
, iteration
);
446 if (new_thread_count
!= 0)
448 /* Found new threads. Restart iteration from beginning. */
453 error ("Cannot find new threads: %s", thread_db_err_str (err
));
456 /* Cache all future symbols that thread_db might request. We can not
457 request symbols at arbitrary states in the remote protocol, only
458 when the client tells us that new symbols are available. So when
459 we load the thread library, make sure to check the entire list. */
462 thread_db_look_up_symbols (void)
464 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
465 const char **sym_list
;
468 for (sym_list
= thread_db
->td_symbol_list_p (); *sym_list
; sym_list
++)
469 look_up_one_symbol (*sym_list
, &unused
, 1);
471 /* We're not interested in any other libraries loaded after this
472 point, only in symbols in libpthread.so. */
473 thread_db
->all_symbols_looked_up
= 1;
477 thread_db_look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
)
479 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
480 int may_ask_gdb
= !thread_db
->all_symbols_looked_up
;
482 /* If we've passed the call to thread_db_look_up_symbols, then
483 anything not in the cache must not exist; we're not interested
484 in any libraries loaded after that point, only in symbols in
485 libpthread.so. It might not be an appropriate time to look
486 up a symbol, e.g. while we're trying to fetch registers. */
487 return look_up_one_symbol (name
, addrp
, may_ask_gdb
);
491 thread_db_get_tls_address (struct thread_info
*thread
, CORE_ADDR offset
,
492 CORE_ADDR load_module
, CORE_ADDR
*address
)
496 struct lwp_info
*lwp
;
497 struct thread_info
*saved_thread
;
498 struct process_info
*proc
;
499 struct thread_db
*thread_db
;
501 proc
= get_thread_process (thread
);
502 thread_db
= proc
->priv
->thread_db
;
504 /* If the thread layer is not (yet) initialized, fail. */
505 if (thread_db
== NULL
|| !thread_db
->all_symbols_looked_up
)
508 /* If td_thr_tls_get_addr is missing rather do not expect td_thr_tlsbase
510 if (thread_db
->td_thr_tls_get_addr_p
== NULL
511 || (load_module
== 0 && thread_db
->td_thr_tlsbase_p
== NULL
))
514 lwp
= get_thread_lwp (thread
);
515 if (!lwp
->thread_known
)
516 find_one_thread (thread
->entry
.id
);
517 if (!lwp
->thread_known
)
520 saved_thread
= current_thread
;
521 current_thread
= thread
;
523 if (load_module
!= 0)
525 /* Note the cast through uintptr_t: this interface only works if
526 a target address fits in a psaddr_t, which is a host pointer.
527 So a 32-bit debugger can not access 64-bit TLS through this. */
528 err
= thread_db
->td_thr_tls_get_addr_p (&lwp
->th
,
529 (psaddr_t
) (uintptr_t) load_module
,
534 /* This code path handles the case of -static -pthread executables:
535 https://sourceware.org/ml/libc-help/2014-03/msg00024.html
536 For older GNU libc r_debug.r_map is NULL. For GNU libc after
537 PR libc/16831 due to GDB PR threads/16954 LOAD_MODULE is also NULL.
538 The constant number 1 depends on GNU __libc_setup_tls
539 initialization of l_tls_modid to 1. */
540 err
= thread_db
->td_thr_tlsbase_p (&lwp
->th
, 1, &addr
);
541 addr
= (char *) addr
+ offset
;
544 current_thread
= saved_thread
;
547 *address
= (CORE_ADDR
) (uintptr_t) addr
;
554 #ifdef USE_LIBTHREAD_DB_DIRECTLY
557 thread_db_load_search (void)
560 struct thread_db
*tdb
;
561 struct process_info
*proc
= current_process ();
563 gdb_assert (proc
->priv
->thread_db
== NULL
);
565 tdb
= XCNEW (struct thread_db
);
566 proc
->priv
->thread_db
= tdb
;
568 tdb
->td_ta_new_p
= &td_ta_new
;
570 /* Attempt to open a connection to the thread library. */
571 err
= tdb
->td_ta_new_p (&tdb
->proc_handle
, &tdb
->thread_agent
);
575 debug_printf ("td_ta_new(): %s\n", thread_db_err_str (err
));
577 proc
->priv
->thread_db
= NULL
;
581 tdb
->td_ta_map_lwp2thr_p
= &td_ta_map_lwp2thr
;
582 tdb
->td_thr_get_info_p
= &td_thr_get_info
;
583 tdb
->td_ta_thr_iter_p
= &td_ta_thr_iter
;
584 tdb
->td_symbol_list_p
= &td_symbol_list
;
586 /* This is required only when thread_db_use_events is on. */
587 tdb
->td_thr_event_enable_p
= &td_thr_event_enable
;
589 /* These are not essential. */
590 tdb
->td_ta_event_addr_p
= &td_ta_event_addr
;
591 tdb
->td_ta_set_event_p
= &td_ta_set_event
;
592 tdb
->td_ta_event_getmsg_p
= &td_ta_event_getmsg
;
593 tdb
->td_thr_tls_get_addr_p
= &td_thr_tls_get_addr
;
594 tdb
->td_thr_tlsbase_p
= &td_thr_tlsbase
;
602 try_thread_db_load_1 (void *handle
)
605 struct thread_db
*tdb
;
606 struct process_info
*proc
= current_process ();
608 gdb_assert (proc
->priv
->thread_db
== NULL
);
610 tdb
= XCNEW (struct thread_db
);
611 proc
->priv
->thread_db
= tdb
;
613 tdb
->handle
= handle
;
615 /* Initialize pointers to the dynamic library functions we will use.
616 Essential functions first. */
618 #define CHK(required, a) \
624 debug_printf ("dlsym: %s\n", dlerror ()); \
628 proc->priv->thread_db = NULL; \
635 #define TDB_DLSYM(tdb, func) \
636 tdb->func ## _p = (func ## _ftype *) dlsym (tdb->handle, #func)
638 CHK (1, TDB_DLSYM (tdb
, td_ta_new
));
640 /* Attempt to open a connection to the thread library. */
641 err
= tdb
->td_ta_new_p (&tdb
->proc_handle
, &tdb
->thread_agent
);
645 debug_printf ("td_ta_new(): %s\n", thread_db_err_str (err
));
647 proc
->priv
->thread_db
= NULL
;
651 CHK (1, TDB_DLSYM (tdb
, td_ta_map_lwp2thr
));
652 CHK (1, TDB_DLSYM (tdb
, td_thr_get_info
));
653 CHK (1, TDB_DLSYM (tdb
, td_ta_thr_iter
));
654 CHK (1, TDB_DLSYM (tdb
, td_symbol_list
));
656 /* This is required only when thread_db_use_events is on. */
657 CHK (thread_db_use_events
, TDB_DLSYM (tdb
, td_thr_event_enable
));
659 /* These are not essential. */
660 CHK (0, TDB_DLSYM (tdb
, td_ta_event_addr
));
661 CHK (0, TDB_DLSYM (tdb
, td_ta_set_event
));
662 CHK (0, TDB_DLSYM (tdb
, td_ta_event_getmsg
));
663 CHK (0, TDB_DLSYM (tdb
, td_thr_tls_get_addr
));
664 CHK (0, TDB_DLSYM (tdb
, td_thr_tlsbase
));
674 /* Lookup a library in which given symbol resides.
675 Note: this is looking in the GDBSERVER process, not in the inferior.
676 Returns library name, or NULL. */
679 dladdr_to_soname (const void *addr
)
683 if (dladdr (addr
, &info
) != 0)
684 return info
.dli_fname
;
691 try_thread_db_load (const char *library
)
696 debug_printf ("Trying host libthread_db library: %s.\n",
698 handle
= dlopen (library
, RTLD_NOW
);
702 debug_printf ("dlopen failed: %s.\n", dlerror ());
707 if (debug_threads
&& strchr (library
, '/') == NULL
)
711 td_init
= dlsym (handle
, "td_init");
714 const char *const libpath
= dladdr_to_soname (td_init
);
717 fprintf (stderr
, "Host %s resolved to: %s.\n",
723 if (try_thread_db_load_1 (handle
))
726 /* This library "refused" to work on current inferior. */
731 /* Handle $sdir in libthread-db-search-path.
732 Look for libthread_db in the system dirs, or wherever a plain
733 dlopen(file_without_path) will look.
734 The result is true for success. */
737 try_thread_db_load_from_sdir (void)
739 return try_thread_db_load (LIBTHREAD_DB_SO
);
742 /* Try to load libthread_db from directory DIR of length DIR_LEN.
743 The result is true for success. */
746 try_thread_db_load_from_dir (const char *dir
, size_t dir_len
)
750 if (dir_len
+ 1 + strlen (LIBTHREAD_DB_SO
) + 1 > sizeof (path
))
752 char *cp
= xmalloc (dir_len
+ 1);
754 memcpy (cp
, dir
, dir_len
);
756 warning (_("libthread-db-search-path component too long,"
757 " ignored: %s."), cp
);
762 memcpy (path
, dir
, dir_len
);
764 strcpy (path
+ dir_len
+ 1, LIBTHREAD_DB_SO
);
765 return try_thread_db_load (path
);
768 /* Search libthread_db_search_path for libthread_db which "agrees"
769 to work on current inferior.
770 The result is true for success. */
773 thread_db_load_search (void)
775 VEC (char_ptr
) *dir_vec
;
779 if (libthread_db_search_path
== NULL
)
780 libthread_db_search_path
= xstrdup (LIBTHREAD_DB_SEARCH_PATH
);
782 dir_vec
= dirnames_to_char_ptr_vec (libthread_db_search_path
);
784 for (i
= 0; VEC_iterate (char_ptr
, dir_vec
, i
, this_dir
); ++i
)
786 const int pdir_len
= sizeof ("$pdir") - 1;
789 this_dir_len
= strlen (this_dir
);
791 if (strncmp (this_dir
, "$pdir", pdir_len
) == 0
792 && (this_dir
[pdir_len
] == '\0'
793 || this_dir
[pdir_len
] == '/'))
795 /* We don't maintain a list of loaded libraries so we don't know
796 where libpthread lives. We *could* fetch the info, but we don't
797 do that yet. Ignore it. */
799 else if (strcmp (this_dir
, "$sdir") == 0)
801 if (try_thread_db_load_from_sdir ())
809 if (try_thread_db_load_from_dir (this_dir
, this_dir_len
))
817 free_char_ptr_vec (dir_vec
);
819 debug_printf ("thread_db_load_search returning %d\n", rc
);
823 #endif /* USE_LIBTHREAD_DB_DIRECTLY */
826 thread_db_init (int use_events
)
828 struct process_info
*proc
= current_process ();
830 /* FIXME drow/2004-10-16: This is the "overall process ID", which
831 GNU/Linux calls tgid, "thread group ID". When we support
832 attaching to threads, the original thread may not be the correct
833 thread. We would have to get the process ID from /proc for NPTL.
834 For LinuxThreads we could do something similar: follow the chain
835 of parent processes until we find the highest one we're attached
836 to, and use its tgid.
838 This isn't the only place in gdbserver that assumes that the first
839 process in the list is the thread group leader. */
841 thread_db_use_events
= use_events
;
843 if (thread_db_load_search ())
845 if (use_events
&& thread_db_enable_reporting () == 0)
847 /* Keep trying; maybe event reporting will work later. */
848 thread_db_mourn (proc
);
852 /* It's best to avoid td_ta_thr_iter if possible. That walks
853 data structures in the inferior's address space that may be
854 corrupted, or, if the target is running, the list may change
855 while we walk it. In the latter case, it's possible that a
856 thread exits just at the exact time that causes GDBserver to
857 get stuck in an infinite loop. If the kernel supports clone
858 events, and /proc/PID/task/ exits, then we already know about
859 all threads in the process. When we need info out of
860 thread_db on a given thread (e.g., for TLS), we'll use
861 find_one_thread then. That uses thread_db entry points that
862 do not walk libpthread's thread list, so should be safe, as
863 well as more efficient. */
865 || !linux_proc_task_list_dir_exists (pid_of (proc
)))
866 thread_db_find_new_threads ();
867 thread_db_look_up_symbols ();
875 any_thread_of (struct inferior_list_entry
*entry
, void *args
)
879 if (ptid_get_pid (entry
->id
) == *pid_p
)
886 switch_to_process (struct process_info
*proc
)
888 int pid
= pid_of (proc
);
891 (struct thread_info
*) find_inferior (&all_threads
,
892 any_thread_of
, &pid
);
895 /* Disconnect from libthread_db and free resources. */
898 disable_thread_event_reporting (struct process_info
*proc
)
900 struct thread_db
*thread_db
= proc
->priv
->thread_db
;
903 td_err_e (*td_ta_clear_event_p
) (const td_thragent_t
*ta
,
904 td_thr_events_t
*event
);
906 #ifndef USE_LIBTHREAD_DB_DIRECTLY
908 = (td_ta_clear_event_ftype
*) dlsym (thread_db
->handle
,
909 "td_ta_clear_event");
911 td_ta_clear_event_p
= &td_ta_clear_event
;
914 if (td_ta_clear_event_p
!= NULL
)
916 struct thread_info
*saved_thread
= current_thread
;
917 td_thr_events_t events
;
919 switch_to_process (proc
);
921 /* Set the process wide mask saying we aren't interested
922 in any events anymore. */
923 td_event_fillset (&events
);
924 (*td_ta_clear_event_p
) (thread_db
->thread_agent
, &events
);
926 current_thread
= saved_thread
;
932 remove_thread_event_breakpoints (struct process_info
*proc
)
934 struct thread_db
*thread_db
= proc
->priv
->thread_db
;
936 if (thread_db
->td_create_bp
!= NULL
)
938 struct thread_info
*saved_thread
= current_thread
;
940 switch_to_process (proc
);
942 delete_breakpoint (thread_db
->td_create_bp
);
943 thread_db
->td_create_bp
= NULL
;
945 current_thread
= saved_thread
;
950 thread_db_detach (struct process_info
*proc
)
952 struct thread_db
*thread_db
= proc
->priv
->thread_db
;
956 disable_thread_event_reporting (proc
);
957 remove_thread_event_breakpoints (proc
);
961 /* Disconnect from libthread_db and free resources. */
964 thread_db_mourn (struct process_info
*proc
)
966 struct thread_db
*thread_db
= proc
->priv
->thread_db
;
969 td_ta_delete_ftype
*td_ta_delete_p
;
971 #ifndef USE_LIBTHREAD_DB_DIRECTLY
972 td_ta_delete_p
= (td_ta_delete_ftype
*) dlsym (thread_db
->handle
, "td_ta_delete");
974 td_ta_delete_p
= &td_ta_delete
;
977 if (td_ta_delete_p
!= NULL
)
978 (*td_ta_delete_p
) (thread_db
->thread_agent
);
980 #ifndef USE_LIBTHREAD_DB_DIRECTLY
981 dlclose (thread_db
->handle
);
982 #endif /* USE_LIBTHREAD_DB_DIRECTLY */
985 proc
->priv
->thread_db
= NULL
;
989 /* Handle "set libthread-db-search-path" monitor command and return 1.
990 For any other command, return 0. */
993 thread_db_handle_monitor_command (char *mon
)
995 const char *cmd
= "set libthread-db-search-path";
996 size_t cmd_len
= strlen (cmd
);
998 if (strncmp (mon
, cmd
, cmd_len
) == 0
999 && (mon
[cmd_len
] == '\0'
1000 || mon
[cmd_len
] == ' '))
1002 const char *cp
= mon
+ cmd_len
;
1004 if (libthread_db_search_path
!= NULL
)
1005 free (libthread_db_search_path
);
1007 /* Skip leading space (if any). */
1008 while (isspace (*cp
))
1012 cp
= LIBTHREAD_DB_SEARCH_PATH
;
1013 libthread_db_search_path
= xstrdup (cp
);
1015 monitor_output ("libthread-db-search-path set to `");
1016 monitor_output (libthread_db_search_path
);
1017 monitor_output ("'\n");
1021 /* Tell server.c to perform default processing. */