1 /* Thread management interface, for the remote server for GDB.
2 Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008
3 Free Software Foundation, Inc.
5 Contributed by MontaVista Software.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "linux-low.h"
26 extern int debug_threads
;
28 static int thread_db_use_events
;
30 #ifdef HAVE_THREAD_DB_H
31 #include <thread_db.h>
34 #include "gdb_proc_service.h"
38 /* Structure that identifies the child process for the
39 <proc_service.h> interface. */
40 static struct ps_prochandle proc_handle
;
42 /* Connection to the libthread_db library. */
43 static td_thragent_t
*thread_agent
;
45 static int find_one_thread (int);
46 static int find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
);
49 thread_db_err_str (td_err_e err
)
56 return "generic 'call succeeded'";
58 return "generic error";
60 return "no thread to satisfy query";
62 return "no sync handle to satisfy query";
64 return "no LWP to satisfy query";
66 return "invalid process handle";
68 return "invalid thread handle";
70 return "invalid synchronization handle";
72 return "invalid thread agent";
76 return "no event message for getmsg";
78 return "FPU register set not available";
80 return "application not linked with libthread";
82 return "requested event is not supported";
84 return "capability not available";
86 return "debugger service failed";
88 return "operation not applicable to";
90 return "no thread-specific data for this thread";
92 return "malloc failed";
94 return "only part of register set was written/read";
96 return "X register set not available for this thread";
97 #ifdef HAVE_TD_VERSION
99 return "version mismatch between libthread_db and libpthread";
102 snprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
109 thread_db_state_str (td_thr_state_e state
)
116 return "stopped by debugger";
125 case TD_THR_STOPPED_ASLEEP
:
126 return "stopped by debugger AND blocked";
128 snprintf (buf
, sizeof (buf
), "unknown thread_db state %d", state
);
135 thread_db_create_event (CORE_ADDR where
)
139 struct process_info
*process
;
142 fprintf (stderr
, "Thread creation event.\n");
144 /* FIXME: This assumes we don't get another event.
145 In the LinuxThreads implementation, this is safe,
146 because all events come from the manager thread
147 (except for its own creation, of course). */
148 err
= td_ta_event_getmsg (thread_agent
, &msg
);
150 fprintf (stderr
, "thread getmsg err: %s\n",
151 thread_db_err_str (err
));
153 /* If we do not know about the main thread yet, this would be a good time to
154 find it. We need to do this to pick up the main thread before any newly
156 process
= get_thread_process (current_inferior
);
157 if (process
->thread_known
== 0)
158 find_one_thread (process
->lwpid
);
160 /* msg.event == TD_EVENT_CREATE */
162 find_new_threads_callback (msg
.th_p
, NULL
);
169 thread_db_death_event (CORE_ADDR where
)
172 fprintf (stderr
, "Thread death event.\n");
179 thread_db_enable_reporting ()
181 td_thr_events_t events
;
185 /* Set the process wide mask saying which events we're interested in. */
186 td_event_emptyset (&events
);
187 td_event_addset (&events
, TD_CREATE
);
190 /* This is reported to be broken in glibc 2.1.3. A different approach
191 will be necessary to support that. */
192 td_event_addset (&events
, TD_DEATH
);
195 err
= td_ta_set_event (thread_agent
, &events
);
198 warning ("Unable to set global thread event mask: %s",
199 thread_db_err_str (err
));
203 /* Get address for thread creation breakpoint. */
204 err
= td_ta_event_addr (thread_agent
, TD_CREATE
, ¬ify
);
207 warning ("Unable to get location for thread creation breakpoint: %s",
208 thread_db_err_str (err
));
211 set_breakpoint_at ((CORE_ADDR
) (unsigned long) notify
.u
.bptaddr
,
212 thread_db_create_event
);
215 /* Don't concern ourselves with reported thread deaths, only
216 with actual thread deaths (via wait). */
218 /* Get address for thread death breakpoint. */
219 err
= td_ta_event_addr (thread_agent
, TD_DEATH
, ¬ify
);
222 warning ("Unable to get location for thread death breakpoint: %s",
223 thread_db_err_str (err
));
226 set_breakpoint_at ((CORE_ADDR
) (unsigned long) notify
.u
.bptaddr
,
227 thread_db_death_event
);
234 find_one_thread (int lwpid
)
239 struct thread_info
*inferior
;
240 struct process_info
*process
;
242 inferior
= (struct thread_info
*) find_inferior_id (&all_threads
, lwpid
);
243 process
= get_thread_process (inferior
);
244 if (process
->thread_known
)
247 /* Get information about this thread. */
248 err
= td_ta_map_lwp2thr (thread_agent
, process
->lwpid
, &th
);
250 error ("Cannot get thread handle for LWP %d: %s",
251 lwpid
, thread_db_err_str (err
));
253 err
= td_thr_get_info (&th
, &ti
);
255 error ("Cannot get thread info for LWP %d: %s",
256 lwpid
, thread_db_err_str (err
));
259 fprintf (stderr
, "Found thread %ld (LWP %d)\n",
260 ti
.ti_tid
, ti
.ti_lid
);
262 if (process
->lwpid
!= ti
.ti_lid
)
264 warning ("PID mismatch! Expected %ld, got %ld",
265 (long) process
->lwpid
, (long) ti
.ti_lid
);
269 if (thread_db_use_events
)
271 err
= td_thr_event_enable (&th
, 1);
273 error ("Cannot enable thread event reporting for %d: %s",
274 ti
.ti_lid
, thread_db_err_str (err
));
277 /* If the new thread ID is zero, a final thread ID will be available
278 later. Do not enable thread debugging yet. */
282 process
->thread_known
= 1;
283 process
->tid
= ti
.ti_tid
;
290 maybe_attach_thread (const td_thrhandle_t
*th_p
, td_thrinfo_t
*ti_p
)
293 struct thread_info
*inferior
;
294 struct process_info
*process
;
296 inferior
= (struct thread_info
*) find_inferior_id (&all_threads
,
298 if (inferior
!= NULL
)
302 fprintf (stderr
, "Attaching to thread %ld (LWP %d)\n",
303 ti_p
->ti_tid
, ti_p
->ti_lid
);
304 linux_attach_lwp (ti_p
->ti_lid
);
305 inferior
= (struct thread_info
*) find_inferior_id (&all_threads
,
307 if (inferior
== NULL
)
309 warning ("Could not attach to thread %ld (LWP %d)\n",
310 ti_p
->ti_tid
, ti_p
->ti_lid
);
314 process
= inferior_target_data (inferior
);
316 process
->tid
= ti_p
->ti_tid
;
317 process
->thread_known
= 1;
320 if (thread_db_use_events
)
322 err
= td_thr_event_enable (th_p
, 1);
324 error ("Cannot enable thread event reporting for %d: %s",
325 ti_p
->ti_lid
, thread_db_err_str (err
));
330 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
335 err
= td_thr_get_info (th_p
, &ti
);
337 error ("Cannot get thread info: %s", thread_db_err_str (err
));
339 /* Check for zombies. */
340 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
343 maybe_attach_thread (th_p
, &ti
);
349 thread_db_find_new_threads (void)
353 /* This function is only called when we first initialize thread_db.
354 First locate the initial thread. If it is not ready for
355 debugging yet, then stop. */
356 if (find_one_thread (all_threads
.head
->id
) == 0)
359 /* Iterate over all user-space threads to discover new threads. */
360 err
= td_ta_thr_iter (thread_agent
, find_new_threads_callback
, NULL
,
361 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
362 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
364 error ("Cannot find new threads: %s", thread_db_err_str (err
));
367 /* Cache all future symbols that thread_db might request. We can not
368 request symbols at arbitrary states in the remote protocol, only
369 when the client tells us that new symbols are available. So when
370 we load the thread library, make sure to check the entire list. */
373 thread_db_look_up_symbols (void)
375 const char **sym_list
= td_symbol_list ();
378 for (sym_list
= td_symbol_list (); *sym_list
; sym_list
++)
379 look_up_one_symbol (*sym_list
, &unused
);
383 thread_db_get_tls_address (struct thread_info
*thread
, CORE_ADDR offset
,
384 CORE_ADDR load_module
, CORE_ADDR
*address
)
386 #if HAVE_TD_THR_TLS_GET_ADDR
389 struct process_info
*process
;
391 process
= get_thread_process (thread
);
392 if (!process
->thread_known
)
393 find_one_thread (process
->lwpid
);
394 if (!process
->thread_known
)
397 /* Note the cast through uintptr_t: this interface only works if
398 a target address fits in a psaddr_t, which is a host pointer.
399 So a 32-bit debugger can not access 64-bit TLS through this. */
400 err
= td_thr_tls_get_addr (&process
->th
, (psaddr_t
) (uintptr_t) load_module
,
404 *address
= (CORE_ADDR
) (uintptr_t) addr
;
415 thread_db_init (int use_events
)
419 /* FIXME drow/2004-10-16: This is the "overall process ID", which
420 GNU/Linux calls tgid, "thread group ID". When we support
421 attaching to threads, the original thread may not be the correct
422 thread. We would have to get the process ID from /proc for NPTL.
423 For LinuxThreads we could do something similar: follow the chain
424 of parent processes until we find the highest one we're attached
425 to, and use its tgid.
427 This isn't the only place in gdbserver that assumes that the first
428 process in the list is the thread group leader. */
429 proc_handle
.pid
= ((struct inferior_list_entry
*)current_inferior
)->id
;
431 /* Allow new symbol lookups. */
432 all_symbols_looked_up
= 0;
434 thread_db_use_events
= use_events
;
436 err
= td_ta_new (&proc_handle
, &thread_agent
);
440 /* No thread library was detected. */
444 /* The thread library was detected. */
446 if (use_events
&& thread_db_enable_reporting () == 0)
448 thread_db_find_new_threads ();
449 thread_db_look_up_symbols ();
450 all_symbols_looked_up
= 1;
454 warning ("error initializing thread_db library: %s",
455 thread_db_err_str (err
));