1 /* Thread management interface, for the remote server for GDB.
2 Copyright (C) 2002-2014 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 "gdb_thread_db.h"
33 #ifndef USE_LIBTHREAD_DB_DIRECTLY
43 /* Structure that identifies the child process for the
44 <proc_service.h> interface. */
45 struct ps_prochandle proc_handle
;
47 /* Connection to the libthread_db library. */
48 td_thragent_t
*thread_agent
;
50 /* If this flag has been set, we've already asked GDB for all
51 symbols we might need; assume symbol cache misses are
53 int all_symbols_looked_up
;
55 #ifndef USE_LIBTHREAD_DB_DIRECTLY
56 /* Handle of the libthread_db from dlopen. */
60 /* Thread creation event breakpoint. The code at this location in
61 the child process will be called by the pthread library whenever
62 a new thread is created. By setting a special breakpoint at this
63 location, GDB can detect when a new thread is created. We obtain
64 this location via the td_ta_event_addr call. Note that if the
65 running kernel supports tracing clones, then we don't need to use
66 (and in fact don't use) this magic thread event breakpoint to
67 learn about threads. */
68 struct breakpoint
*td_create_bp
;
70 /* Addresses of libthread_db functions. */
71 td_err_e (*td_ta_new_p
) (struct ps_prochandle
* ps
, td_thragent_t
**ta
);
72 td_err_e (*td_ta_event_getmsg_p
) (const td_thragent_t
*ta
,
74 td_err_e (*td_ta_set_event_p
) (const td_thragent_t
*ta
,
75 td_thr_events_t
*event
);
76 td_err_e (*td_ta_event_addr_p
) (const td_thragent_t
*ta
,
77 td_event_e event
, td_notify_t
*ptr
);
78 td_err_e (*td_ta_map_lwp2thr_p
) (const td_thragent_t
*ta
, lwpid_t lwpid
,
80 td_err_e (*td_thr_get_info_p
) (const td_thrhandle_t
*th
,
82 td_err_e (*td_thr_event_enable_p
) (const td_thrhandle_t
*th
, int event
);
83 td_err_e (*td_ta_thr_iter_p
) (const td_thragent_t
*ta
,
84 td_thr_iter_f
*callback
, void *cbdata_p
,
85 td_thr_state_e state
, int ti_pri
,
86 sigset_t
*ti_sigmask_p
,
87 unsigned int ti_user_flags
);
88 td_err_e (*td_thr_tls_get_addr_p
) (const td_thrhandle_t
*th
,
90 size_t offset
, psaddr_t
*address
);
91 td_err_e (*td_thr_tlsbase_p
) (const td_thrhandle_t
*th
,
92 unsigned long int modid
,
94 const char ** (*td_symbol_list_p
) (void);
97 static char *libthread_db_search_path
;
99 static int find_one_thread (ptid_t
);
100 static int find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
);
103 thread_db_err_str (td_err_e err
)
110 return "generic 'call succeeded'";
112 return "generic error";
114 return "no thread to satisfy query";
116 return "no sync handle to satisfy query";
118 return "no LWP to satisfy query";
120 return "invalid process handle";
122 return "invalid thread handle";
124 return "invalid synchronization handle";
126 return "invalid thread agent";
128 return "invalid key";
130 return "no event message for getmsg";
132 return "FPU register set not available";
134 return "application not linked with libthread";
136 return "requested event is not supported";
138 return "capability not available";
140 return "debugger service failed";
142 return "operation not applicable to";
144 return "no thread-specific data for this thread";
146 return "malloc failed";
148 return "only part of register set was written/read";
150 return "X register set not available for this thread";
151 #ifdef HAVE_TD_VERSION
153 return "version mismatch between libthread_db and libpthread";
156 xsnprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
163 thread_db_state_str (td_thr_state_e state
)
170 return "stopped by debugger";
179 case TD_THR_STOPPED_ASLEEP
:
180 return "stopped by debugger AND blocked";
182 xsnprintf (buf
, sizeof (buf
), "unknown thread_db state %d", state
);
189 thread_db_create_event (CORE_ADDR where
)
193 struct lwp_info
*lwp
;
194 struct thread_db
*thread_db
= current_process ()->private->thread_db
;
196 if (thread_db
->td_ta_event_getmsg_p
== NULL
)
197 fatal ("unexpected thread_db->td_ta_event_getmsg_p == NULL");
200 debug_printf ("Thread creation event.\n");
202 /* FIXME: This assumes we don't get another event.
203 In the LinuxThreads implementation, this is safe,
204 because all events come from the manager thread
205 (except for its own creation, of course). */
206 err
= thread_db
->td_ta_event_getmsg_p (thread_db
->thread_agent
, &msg
);
208 fprintf (stderr
, "thread getmsg err: %s\n",
209 thread_db_err_str (err
));
211 /* If we do not know about the main thread yet, this would be a good time to
212 find it. We need to do this to pick up the main thread before any newly
214 lwp
= get_thread_lwp (current_inferior
);
215 if (lwp
->thread_known
== 0)
216 find_one_thread (current_inferior
->entry
.id
);
218 /* msg.event == TD_EVENT_CREATE */
220 find_new_threads_callback (msg
.th_p
, NULL
);
226 thread_db_enable_reporting (void)
228 td_thr_events_t events
;
231 struct thread_db
*thread_db
= current_process ()->private->thread_db
;
233 if (thread_db
->td_ta_set_event_p
== NULL
234 || thread_db
->td_ta_event_addr_p
== NULL
235 || thread_db
->td_ta_event_getmsg_p
== NULL
)
236 /* This libthread_db is missing required support. */
239 /* Set the process wide mask saying which events we're interested in. */
240 td_event_emptyset (&events
);
241 td_event_addset (&events
, TD_CREATE
);
243 err
= thread_db
->td_ta_set_event_p (thread_db
->thread_agent
, &events
);
246 warning ("Unable to set global thread event mask: %s",
247 thread_db_err_str (err
));
251 /* Get address for thread creation breakpoint. */
252 err
= thread_db
->td_ta_event_addr_p (thread_db
->thread_agent
, TD_CREATE
,
256 warning ("Unable to get location for thread creation breakpoint: %s",
257 thread_db_err_str (err
));
260 thread_db
->td_create_bp
261 = set_breakpoint_at ((CORE_ADDR
) (unsigned long) notify
.u
.bptaddr
,
262 thread_db_create_event
);
268 find_one_thread (ptid_t ptid
)
273 struct thread_info
*inferior
;
274 struct lwp_info
*lwp
;
275 struct thread_db
*thread_db
= current_process ()->private->thread_db
;
276 int lwpid
= ptid_get_lwp (ptid
);
278 inferior
= (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
279 lwp
= get_thread_lwp (inferior
);
280 if (lwp
->thread_known
)
283 /* Get information about this thread. */
284 err
= thread_db
->td_ta_map_lwp2thr_p (thread_db
->thread_agent
, lwpid
, &th
);
286 error ("Cannot get thread handle for LWP %d: %s",
287 lwpid
, thread_db_err_str (err
));
289 err
= thread_db
->td_thr_get_info_p (&th
, &ti
);
291 error ("Cannot get thread info for LWP %d: %s",
292 lwpid
, thread_db_err_str (err
));
295 debug_printf ("Found thread %ld (LWP %d)\n",
296 ti
.ti_tid
, ti
.ti_lid
);
298 if (lwpid
!= ti
.ti_lid
)
300 warning ("PID mismatch! Expected %ld, got %ld",
301 (long) lwpid
, (long) ti
.ti_lid
);
305 if (thread_db_use_events
)
307 err
= thread_db
->td_thr_event_enable_p (&th
, 1);
309 error ("Cannot enable thread event reporting for %d: %s",
310 ti
.ti_lid
, thread_db_err_str (err
));
313 /* If the new thread ID is zero, a final thread ID will be available
314 later. Do not enable thread debugging yet. */
318 lwp
->thread_known
= 1;
324 /* Attach a thread. Return true on success. */
327 attach_thread (const td_thrhandle_t
*th_p
, td_thrinfo_t
*ti_p
)
329 struct process_info
*proc
= current_process ();
330 int pid
= pid_of (proc
);
331 ptid_t ptid
= ptid_build (pid
, ti_p
->ti_lid
, 0);
332 struct lwp_info
*lwp
;
336 debug_printf ("Attaching to thread %ld (LWP %d)\n",
337 ti_p
->ti_tid
, ti_p
->ti_lid
);
338 err
= linux_attach_lwp (ptid
);
341 warning ("Could not attach to thread %ld (LWP %d): %s\n",
342 ti_p
->ti_tid
, ti_p
->ti_lid
,
343 linux_attach_fail_reason_string (ptid
, err
));
347 lwp
= find_lwp_pid (ptid
);
348 gdb_assert (lwp
!= NULL
);
349 lwp
->thread_known
= 1;
352 if (thread_db_use_events
)
355 struct thread_db
*thread_db
= proc
->private->thread_db
;
357 err
= thread_db
->td_thr_event_enable_p (th_p
, 1);
359 error ("Cannot enable thread event reporting for %d: %s",
360 ti_p
->ti_lid
, thread_db_err_str (err
));
366 /* Attach thread if we haven't seen it yet.
367 Increment *COUNTER if we have attached a new thread.
368 Return false on failure. */
371 maybe_attach_thread (const td_thrhandle_t
*th_p
, td_thrinfo_t
*ti_p
,
374 struct lwp_info
*lwp
;
376 lwp
= find_lwp_pid (pid_to_ptid (ti_p
->ti_lid
));
380 if (!attach_thread (th_p
, ti_p
))
390 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
394 struct thread_db
*thread_db
= current_process ()->private->thread_db
;
396 err
= thread_db
->td_thr_get_info_p (th_p
, &ti
);
398 error ("Cannot get thread info: %s", thread_db_err_str (err
));
400 /* Check for zombies. */
401 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
404 if (!maybe_attach_thread (th_p
, &ti
, (int *) data
))
406 /* Terminate iteration early: we might be looking at stale data in
407 the inferior. The thread_db_find_new_threads will retry. */
415 thread_db_find_new_threads (void)
418 ptid_t ptid
= current_ptid
;
419 struct thread_db
*thread_db
= current_process ()->private->thread_db
;
422 /* This function is only called when we first initialize thread_db.
423 First locate the initial thread. If it is not ready for
424 debugging yet, then stop. */
425 if (find_one_thread (ptid
) == 0)
428 /* Require 4 successive iterations which do not find any new threads.
429 The 4 is a heuristic: there is an inherent race here, and I have
430 seen that 2 iterations in a row are not always sufficient to
431 "capture" all threads. */
432 for (loop
= 0, iteration
= 0; loop
< 4; ++loop
, ++iteration
)
434 int new_thread_count
= 0;
436 /* Iterate over all user-space threads to discover new threads. */
437 err
= thread_db
->td_ta_thr_iter_p (thread_db
->thread_agent
,
438 find_new_threads_callback
,
441 TD_THR_LOWEST_PRIORITY
,
442 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
444 debug_printf ("Found %d threads in iteration %d.\n",
445 new_thread_count
, iteration
);
447 if (new_thread_count
!= 0)
449 /* Found new threads. Restart iteration from beginning. */
454 error ("Cannot find new threads: %s", thread_db_err_str (err
));
457 /* Cache all future symbols that thread_db might request. We can not
458 request symbols at arbitrary states in the remote protocol, only
459 when the client tells us that new symbols are available. So when
460 we load the thread library, make sure to check the entire list. */
463 thread_db_look_up_symbols (void)
465 struct thread_db
*thread_db
= current_process ()->private->thread_db
;
466 const char **sym_list
;
469 for (sym_list
= thread_db
->td_symbol_list_p (); *sym_list
; sym_list
++)
470 look_up_one_symbol (*sym_list
, &unused
, 1);
472 /* We're not interested in any other libraries loaded after this
473 point, only in symbols in libpthread.so. */
474 thread_db
->all_symbols_looked_up
= 1;
478 thread_db_look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
)
480 struct thread_db
*thread_db
= current_process ()->private->thread_db
;
481 int may_ask_gdb
= !thread_db
->all_symbols_looked_up
;
483 /* If we've passed the call to thread_db_look_up_symbols, then
484 anything not in the cache must not exist; we're not interested
485 in any libraries loaded after that point, only in symbols in
486 libpthread.so. It might not be an appropriate time to look
487 up a symbol, e.g. while we're trying to fetch registers. */
488 return look_up_one_symbol (name
, addrp
, may_ask_gdb
);
492 thread_db_get_tls_address (struct thread_info
*thread
, CORE_ADDR offset
,
493 CORE_ADDR load_module
, CORE_ADDR
*address
)
497 struct lwp_info
*lwp
;
498 struct thread_info
*saved_inferior
;
499 struct process_info
*proc
;
500 struct thread_db
*thread_db
;
502 proc
= get_thread_process (thread
);
503 thread_db
= proc
->private->thread_db
;
505 /* If the thread layer is not (yet) initialized, fail. */
506 if (thread_db
== NULL
|| !thread_db
->all_symbols_looked_up
)
509 /* If td_thr_tls_get_addr is missing rather do not expect td_thr_tlsbase
511 if (thread_db
->td_thr_tls_get_addr_p
== NULL
512 || (load_module
== 0 && thread_db
->td_thr_tlsbase_p
== NULL
))
515 lwp
= get_thread_lwp (thread
);
516 if (!lwp
->thread_known
)
517 find_one_thread (thread
->entry
.id
);
518 if (!lwp
->thread_known
)
521 saved_inferior
= current_inferior
;
522 current_inferior
= thread
;
524 if (load_module
!= 0)
526 /* Note the cast through uintptr_t: this interface only works if
527 a target address fits in a psaddr_t, which is a host pointer.
528 So a 32-bit debugger can not access 64-bit TLS through this. */
529 err
= thread_db
->td_thr_tls_get_addr_p (&lwp
->th
,
530 (psaddr_t
) (uintptr_t) load_module
,
535 /* This code path handles the case of -static -pthread executables:
536 https://sourceware.org/ml/libc-help/2014-03/msg00024.html
537 For older GNU libc r_debug.r_map is NULL. For GNU libc after
538 PR libc/16831 due to GDB PR threads/16954 LOAD_MODULE is also NULL.
539 The constant number 1 depends on GNU __libc_setup_tls
540 initialization of l_tls_modid to 1. */
541 err
= thread_db
->td_thr_tlsbase_p (&lwp
->th
, 1, &addr
);
542 addr
= (char *) addr
+ offset
;
545 current_inferior
= saved_inferior
;
548 *address
= (CORE_ADDR
) (uintptr_t) addr
;
555 #ifdef USE_LIBTHREAD_DB_DIRECTLY
558 thread_db_load_search (void)
561 struct thread_db
*tdb
;
562 struct process_info
*proc
= current_process ();
564 if (proc
->private->thread_db
!= NULL
)
565 fatal ("unexpected: proc->private->thread_db != NULL");
567 tdb
= xcalloc (1, sizeof (*tdb
));
568 proc
->private->thread_db
= tdb
;
570 tdb
->td_ta_new_p
= &td_ta_new
;
572 /* Attempt to open a connection to the thread library. */
573 err
= tdb
->td_ta_new_p (&tdb
->proc_handle
, &tdb
->thread_agent
);
577 debug_printf ("td_ta_new(): %s\n", thread_db_err_str (err
));
579 proc
->private->thread_db
= NULL
;
583 tdb
->td_ta_map_lwp2thr_p
= &td_ta_map_lwp2thr
;
584 tdb
->td_thr_get_info_p
= &td_thr_get_info
;
585 tdb
->td_ta_thr_iter_p
= &td_ta_thr_iter
;
586 tdb
->td_symbol_list_p
= &td_symbol_list
;
588 /* This is required only when thread_db_use_events is on. */
589 tdb
->td_thr_event_enable_p
= &td_thr_event_enable
;
591 /* These are not essential. */
592 tdb
->td_ta_event_addr_p
= &td_ta_event_addr
;
593 tdb
->td_ta_set_event_p
= &td_ta_set_event
;
594 tdb
->td_ta_event_getmsg_p
= &td_ta_event_getmsg
;
595 tdb
->td_thr_tls_get_addr_p
= &td_thr_tls_get_addr
;
596 tdb
->td_thr_tlsbase_p
= &td_thr_tlsbase
;
604 try_thread_db_load_1 (void *handle
)
607 struct thread_db
*tdb
;
608 struct process_info
*proc
= current_process ();
610 if (proc
->private->thread_db
!= NULL
)
611 fatal ("unexpected: proc->private->thread_db != NULL");
613 tdb
= xcalloc (1, sizeof (*tdb
));
614 proc
->private->thread_db
= tdb
;
616 tdb
->handle
= handle
;
618 /* Initialize pointers to the dynamic library functions we will use.
619 Essential functions first. */
621 #define CHK(required, a) \
627 debug_printf ("dlsym: %s\n", dlerror ()); \
631 proc->private->thread_db = NULL; \
638 CHK (1, tdb
->td_ta_new_p
= dlsym (handle
, "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
->private->thread_db
= NULL
;
651 CHK (1, tdb
->td_ta_map_lwp2thr_p
= dlsym (handle
, "td_ta_map_lwp2thr"));
652 CHK (1, tdb
->td_thr_get_info_p
= dlsym (handle
, "td_thr_get_info"));
653 CHK (1, tdb
->td_ta_thr_iter_p
= dlsym (handle
, "td_ta_thr_iter"));
654 CHK (1, tdb
->td_symbol_list_p
= dlsym (handle
, "td_symbol_list"));
656 /* This is required only when thread_db_use_events is on. */
657 CHK (thread_db_use_events
,
658 tdb
->td_thr_event_enable_p
= dlsym (handle
, "td_thr_event_enable"));
660 /* These are not essential. */
661 CHK (0, tdb
->td_ta_event_addr_p
= dlsym (handle
, "td_ta_event_addr"));
662 CHK (0, tdb
->td_ta_set_event_p
= dlsym (handle
, "td_ta_set_event"));
663 CHK (0, tdb
->td_ta_event_getmsg_p
= dlsym (handle
, "td_ta_event_getmsg"));
664 CHK (0, tdb
->td_thr_tls_get_addr_p
= dlsym (handle
, "td_thr_tls_get_addr"));
665 CHK (0, tdb
->td_thr_tlsbase_p
= dlsym (handle
, "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
);
851 thread_db_find_new_threads ();
852 thread_db_look_up_symbols ();
860 any_thread_of (struct inferior_list_entry
*entry
, void *args
)
864 if (ptid_get_pid (entry
->id
) == *pid_p
)
871 switch_to_process (struct process_info
*proc
)
873 int pid
= pid_of (proc
);
876 (struct thread_info
*) find_inferior (&all_threads
,
877 any_thread_of
, &pid
);
880 /* Disconnect from libthread_db and free resources. */
883 disable_thread_event_reporting (struct process_info
*proc
)
885 struct thread_db
*thread_db
= proc
->private->thread_db
;
888 td_err_e (*td_ta_clear_event_p
) (const td_thragent_t
*ta
,
889 td_thr_events_t
*event
);
891 #ifndef USE_LIBTHREAD_DB_DIRECTLY
892 td_ta_clear_event_p
= dlsym (thread_db
->handle
, "td_ta_clear_event");
894 td_ta_clear_event_p
= &td_ta_clear_event
;
897 if (td_ta_clear_event_p
!= NULL
)
899 struct thread_info
*saved_inferior
= current_inferior
;
900 td_thr_events_t events
;
902 switch_to_process (proc
);
904 /* Set the process wide mask saying we aren't interested
905 in any events anymore. */
906 td_event_fillset (&events
);
907 (*td_ta_clear_event_p
) (thread_db
->thread_agent
, &events
);
909 current_inferior
= saved_inferior
;
915 remove_thread_event_breakpoints (struct process_info
*proc
)
917 struct thread_db
*thread_db
= proc
->private->thread_db
;
919 if (thread_db
->td_create_bp
!= NULL
)
921 struct thread_info
*saved_inferior
= current_inferior
;
923 switch_to_process (proc
);
925 delete_breakpoint (thread_db
->td_create_bp
);
926 thread_db
->td_create_bp
= NULL
;
928 current_inferior
= saved_inferior
;
933 thread_db_detach (struct process_info
*proc
)
935 struct thread_db
*thread_db
= proc
->private->thread_db
;
939 disable_thread_event_reporting (proc
);
940 remove_thread_event_breakpoints (proc
);
944 /* Disconnect from libthread_db and free resources. */
947 thread_db_mourn (struct process_info
*proc
)
949 struct thread_db
*thread_db
= proc
->private->thread_db
;
952 td_err_e (*td_ta_delete_p
) (td_thragent_t
*);
954 #ifndef USE_LIBTHREAD_DB_DIRECTLY
955 td_ta_delete_p
= dlsym (thread_db
->handle
, "td_ta_delete");
957 td_ta_delete_p
= &td_ta_delete
;
960 if (td_ta_delete_p
!= NULL
)
961 (*td_ta_delete_p
) (thread_db
->thread_agent
);
963 #ifndef USE_LIBTHREAD_DB_DIRECTLY
964 dlclose (thread_db
->handle
);
965 #endif /* USE_LIBTHREAD_DB_DIRECTLY */
968 proc
->private->thread_db
= NULL
;
972 /* Handle "set libthread-db-search-path" monitor command and return 1.
973 For any other command, return 0. */
976 thread_db_handle_monitor_command (char *mon
)
978 const char *cmd
= "set libthread-db-search-path";
979 size_t cmd_len
= strlen (cmd
);
981 if (strncmp (mon
, cmd
, cmd_len
) == 0
982 && (mon
[cmd_len
] == '\0'
983 || mon
[cmd_len
] == ' '))
985 const char *cp
= mon
+ cmd_len
;
987 if (libthread_db_search_path
!= NULL
)
988 free (libthread_db_search_path
);
990 /* Skip leading space (if any). */
991 while (isspace (*cp
))
995 cp
= LIBTHREAD_DB_SEARCH_PATH
;
996 libthread_db_search_path
= xstrdup (cp
);
998 monitor_output ("libthread-db-search-path set to `");
999 monitor_output (libthread_db_search_path
);
1000 monitor_output ("'\n");
1004 /* Tell server.c to perform default processing. */