1 /* Thread management interface, for the remote server for GDB.
2 Copyright (C) 2002, 2004, 2005, 2006, 2007 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 2 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, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
25 #include "linux-low.h"
27 extern int debug_threads
;
29 #ifdef HAVE_THREAD_DB_H
30 #include <thread_db.h>
33 #include "gdb_proc_service.h"
37 /* Structure that identifies the child process for the
38 <proc_service.h> interface. */
39 static struct ps_prochandle proc_handle
;
41 /* Connection to the libthread_db library. */
42 static td_thragent_t
*thread_agent
;
44 static int find_first_thread (void);
45 static int find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
);
48 thread_db_err_str (td_err_e err
)
55 return "generic 'call succeeded'";
57 return "generic error";
59 return "no thread to satisfy query";
61 return "no sync handle to satisfy query";
63 return "no LWP to satisfy query";
65 return "invalid process handle";
67 return "invalid thread handle";
69 return "invalid synchronization handle";
71 return "invalid thread agent";
75 return "no event message for getmsg";
77 return "FPU register set not available";
79 return "application not linked with libthread";
81 return "requested event is not supported";
83 return "capability not available";
85 return "debugger service failed";
87 return "operation not applicable to";
89 return "no thread-specific data for this thread";
91 return "malloc failed";
93 return "only part of register set was written/read";
95 return "X register set not available for this thread";
96 #ifdef HAVE_TD_VERSION
98 return "version mismatch between libthread_db and libpthread";
101 snprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
108 thread_db_state_str (td_thr_state_e state
)
115 return "stopped by debugger";
124 case TD_THR_STOPPED_ASLEEP
:
125 return "stopped by debugger AND blocked";
127 snprintf (buf
, sizeof (buf
), "unknown thread_db state %d", state
);
134 thread_db_create_event (CORE_ADDR where
)
138 struct process_info
*process
;
141 fprintf (stderr
, "Thread creation event.\n");
143 /* FIXME: This assumes we don't get another event.
144 In the LinuxThreads implementation, this is safe,
145 because all events come from the manager thread
146 (except for its own creation, of course). */
147 err
= td_ta_event_getmsg (thread_agent
, &msg
);
149 fprintf (stderr
, "thread getmsg err: %s\n",
150 thread_db_err_str (err
));
152 /* If we do not know about the main thread yet, this would be a good time to
153 find it. We need to do this to pick up the main thread before any newly
155 process
= get_thread_process (current_inferior
);
156 if (process
->thread_known
== 0)
157 find_first_thread ();
159 /* msg.event == TD_EVENT_CREATE */
161 find_new_threads_callback (msg
.th_p
, NULL
);
166 thread_db_death_event (CORE_ADDR where
)
169 fprintf (stderr
, "Thread death event.\n");
174 thread_db_enable_reporting ()
176 td_thr_events_t events
;
180 /* Set the process wide mask saying which events we're interested in. */
181 td_event_emptyset (&events
);
182 td_event_addset (&events
, TD_CREATE
);
185 /* This is reported to be broken in glibc 2.1.3. A different approach
186 will be necessary to support that. */
187 td_event_addset (&events
, TD_DEATH
);
190 err
= td_ta_set_event (thread_agent
, &events
);
193 warning ("Unable to set global thread event mask: %s",
194 thread_db_err_str (err
));
198 /* Get address for thread creation breakpoint. */
199 err
= td_ta_event_addr (thread_agent
, TD_CREATE
, ¬ify
);
202 warning ("Unable to get location for thread creation breakpoint: %s",
203 thread_db_err_str (err
));
206 set_breakpoint_at ((CORE_ADDR
) (unsigned long) notify
.u
.bptaddr
,
207 thread_db_create_event
);
210 /* Don't concern ourselves with reported thread deaths, only
211 with actual thread deaths (via wait). */
213 /* Get address for thread death breakpoint. */
214 err
= td_ta_event_addr (thread_agent
, TD_DEATH
, ¬ify
);
217 warning ("Unable to get location for thread death breakpoint: %s",
218 thread_db_err_str (err
));
221 set_breakpoint_at ((CORE_ADDR
) (unsigned long) notify
.u
.bptaddr
,
222 thread_db_death_event
);
229 find_first_thread (void)
234 struct thread_info
*inferior
;
235 struct process_info
*process
;
237 inferior
= (struct thread_info
*) all_threads
.head
;
238 process
= get_thread_process (inferior
);
239 if (process
->thread_known
)
242 /* Get information about the one thread we know we have. */
243 err
= td_ta_map_lwp2thr (thread_agent
, process
->lwpid
, &th
);
245 error ("Cannot get first thread handle: %s", thread_db_err_str (err
));
247 err
= td_thr_get_info (&th
, &ti
);
249 error ("Cannot get first thread info: %s", thread_db_err_str (err
));
252 fprintf (stderr
, "Found first thread %ld (LWP %d)\n",
253 ti
.ti_tid
, ti
.ti_lid
);
255 if (process
->lwpid
!= ti
.ti_lid
)
256 fatal ("PID mismatch! Expected %ld, got %ld",
257 (long) process
->lwpid
, (long) ti
.ti_lid
);
259 /* If the new thread ID is zero, a final thread ID will be available
260 later. Do not enable thread debugging yet. */
263 err
= td_thr_event_enable (&th
, 1);
265 error ("Cannot enable thread event reporting for %d: %s",
266 ti
.ti_lid
, thread_db_err_str (err
));
270 /* Switch to indexing the threads list by TID. */
271 change_inferior_id (&all_threads
, ti
.ti_tid
);
273 new_thread_notify (ti
.ti_tid
);
275 process
->tid
= ti
.ti_tid
;
276 process
->lwpid
= ti
.ti_lid
;
277 process
->thread_known
= 1;
280 err
= td_thr_event_enable (&th
, 1);
282 error ("Cannot enable thread event reporting for %d: %s",
283 ti
.ti_lid
, thread_db_err_str (err
));
289 maybe_attach_thread (const td_thrhandle_t
*th_p
, td_thrinfo_t
*ti_p
)
292 struct thread_info
*inferior
;
293 struct process_info
*process
;
295 inferior
= (struct thread_info
*) find_inferior_id (&all_threads
,
297 if (inferior
!= NULL
)
301 fprintf (stderr
, "Attaching to thread %ld (LWP %d)\n",
302 ti_p
->ti_tid
, ti_p
->ti_lid
);
303 linux_attach_lwp (ti_p
->ti_lid
, ti_p
->ti_tid
);
304 inferior
= (struct thread_info
*) find_inferior_id (&all_threads
,
306 if (inferior
== NULL
)
308 warning ("Could not attach to thread %ld (LWP %d)\n",
309 ti_p
->ti_tid
, ti_p
->ti_lid
);
313 process
= inferior_target_data (inferior
);
315 new_thread_notify (ti_p
->ti_tid
);
317 process
->tid
= ti_p
->ti_tid
;
318 process
->lwpid
= ti_p
->ti_lid
;
320 process
->thread_known
= 1;
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
));
329 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
334 err
= td_thr_get_info (th_p
, &ti
);
336 error ("Cannot get thread info: %s", thread_db_err_str (err
));
338 /* Check for zombies. */
339 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
342 maybe_attach_thread (th_p
, &ti
);
348 thread_db_find_new_threads (void)
352 /* This function is only called when we first initialize thread_db.
353 First locate the initial thread. If it is not ready for
354 debugging yet, then stop. */
355 if (find_first_thread () == 0)
358 /* Iterate over all user-space threads to discover new threads. */
359 err
= td_ta_thr_iter (thread_agent
, find_new_threads_callback
, NULL
,
360 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
361 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
363 error ("Cannot find new threads: %s", thread_db_err_str (err
));
366 /* Cache all future symbols that thread_db might request. We can not
367 request symbols at arbitrary states in the remote protocol, only
368 when the client tells us that new symbols are available. So when
369 we load the thread library, make sure to check the entire list. */
372 thread_db_look_up_symbols (void)
374 const char **sym_list
= td_symbol_list ();
377 for (sym_list
= td_symbol_list (); *sym_list
; sym_list
++)
378 look_up_one_symbol (*sym_list
, &unused
);
382 thread_db_get_tls_address (struct thread_info
*thread
, CORE_ADDR offset
,
383 CORE_ADDR load_module
, CORE_ADDR
*address
)
385 #if HAVE_TD_THR_TLS_GET_ADDR
388 struct process_info
*process
;
390 process
= get_thread_process (thread
);
391 if (!process
->thread_known
)
392 find_first_thread ();
393 if (!process
->thread_known
)
396 /* Note the cast through uintptr_t: this interface only works if
397 a target address fits in a psaddr_t, which is a host pointer.
398 So a 32-bit debugger can not access 64-bit TLS through this. */
399 err
= td_thr_tls_get_addr (&process
->th
, (psaddr_t
) (uintptr_t) load_module
,
403 *address
= (CORE_ADDR
) (uintptr_t) addr
;
418 /* FIXME drow/2004-10-16: This is the "overall process ID", which
419 GNU/Linux calls tgid, "thread group ID". When we support
420 attaching to threads, the original thread may not be the correct
421 thread. We would have to get the process ID from /proc for NPTL.
422 For LinuxThreads we could do something similar: follow the chain
423 of parent processes until we find the highest one we're attached
424 to, and use its tgid.
426 This isn't the only place in gdbserver that assumes that the first
427 process in the list is the thread group leader. */
428 proc_handle
.pid
= ((struct inferior_list_entry
*)current_inferior
)->id
;
430 /* Allow new symbol lookups. */
431 all_symbols_looked_up
= 0;
433 err
= td_ta_new (&proc_handle
, &thread_agent
);
437 /* No thread library was detected. */
441 /* The thread library was detected. */
443 if (thread_db_enable_reporting () == 0)
445 thread_db_find_new_threads ();
446 thread_db_look_up_symbols ();
447 all_symbols_looked_up
= 1;
451 warning ("error initializing thread_db library: %s",
452 thread_db_err_str (err
));