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 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 #ifdef HAVE_THREAD_DB_H
28 #include <thread_db.h>
31 #include "gdb_proc_service.h"
35 /* Structure that identifies the child process for the
36 <proc_service.h> interface. */
37 static struct ps_prochandle proc_handle;
39 /* Connection to the libthread_db library. */
40 static td_thragent_t *thread_agent;
42 static int find_first_thread (void);
43 static int find_new_threads_callback (const td_thrhandle_t *th_p, void *data);
46 thread_db_err_str (td_err_e err)
53 return "generic 'call succeeded'";
55 return "generic error";
57 return "no thread to satisfy query";
59 return "no sync handle to satisfy query";
61 return "no LWP to satisfy query";
63 return "invalid process handle";
65 return "invalid thread handle";
67 return "invalid synchronization handle";
69 return "invalid thread agent";
73 return "no event message for getmsg";
75 return "FPU register set not available";
77 return "application not linked with libthread";
79 return "requested event is not supported";
81 return "capability not available";
83 return "debugger service failed";
85 return "operation not applicable to";
87 return "no thread-specific data for this thread";
89 return "malloc failed";
91 return "only part of register set was written/read";
93 return "X register set not available for this thread";
94 #ifdef HAVE_TD_VERSION
96 return "version mismatch between libthread_db and libpthread";
99 snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err);
106 thread_db_state_str (td_thr_state_e state)
113 return "stopped by debugger";
122 case TD_THR_STOPPED_ASLEEP:
123 return "stopped by debugger AND blocked";
125 snprintf (buf, sizeof (buf), "unknown thread_db state %d", state);
132 thread_db_create_event (CORE_ADDR where)
136 struct process_info *process;
139 fprintf (stderr, "Thread creation event.\n");
141 /* FIXME: This assumes we don't get another event.
142 In the LinuxThreads implementation, this is safe,
143 because all events come from the manager thread
144 (except for its own creation, of course). */
145 err = td_ta_event_getmsg (thread_agent, &msg);
147 fprintf (stderr, "thread getmsg err: %s\n",
148 thread_db_err_str (err));
150 /* If we do not know about the main thread yet, this would be a good time to
151 find it. We need to do this to pick up the main thread before any newly
153 process = get_thread_process (current_inferior);
154 if (process->thread_known == 0)
155 find_first_thread ();
157 /* msg.event == TD_EVENT_CREATE */
159 find_new_threads_callback (msg.th_p, NULL);
164 thread_db_death_event (CORE_ADDR where)
167 fprintf (stderr, "Thread death event.\n");
172 thread_db_enable_reporting ()
174 td_thr_events_t events;
178 /* Set the process wide mask saying which events we're interested in. */
179 td_event_emptyset (&events);
180 td_event_addset (&events, TD_CREATE);
183 /* This is reported to be broken in glibc 2.1.3. A different approach
184 will be necessary to support that. */
185 td_event_addset (&events, TD_DEATH);
188 err = td_ta_set_event (thread_agent, &events);
191 warning ("Unable to set global thread event mask: %s",
192 thread_db_err_str (err));
196 /* Get address for thread creation breakpoint. */
197 err = td_ta_event_addr (thread_agent, TD_CREATE, ¬ify);
200 warning ("Unable to get location for thread creation breakpoint: %s",
201 thread_db_err_str (err));
204 set_breakpoint_at ((CORE_ADDR) (unsigned long) notify.u.bptaddr,
205 thread_db_create_event);
208 /* Don't concern ourselves with reported thread deaths, only
209 with actual thread deaths (via wait). */
211 /* Get address for thread death breakpoint. */
212 err = td_ta_event_addr (thread_agent, TD_DEATH, ¬ify);
215 warning ("Unable to get location for thread death breakpoint: %s",
216 thread_db_err_str (err));
219 set_breakpoint_at ((CORE_ADDR) (unsigned long) notify.u.bptaddr,
220 thread_db_death_event);
227 find_first_thread (void)
232 struct thread_info *inferior;
233 struct process_info *process;
235 inferior = (struct thread_info *) all_threads.head;
236 process = get_thread_process (inferior);
237 if (process->thread_known)
240 /* Get information about the one thread we know we have. */
241 err = td_ta_map_lwp2thr (thread_agent, process->lwpid, &th);
243 error ("Cannot get first thread handle: %s", thread_db_err_str (err));
245 err = td_thr_get_info (&th, &ti);
247 error ("Cannot get first thread info: %s", thread_db_err_str (err));
250 fprintf (stderr, "Found first thread %ld (LWP %d)\n",
251 ti.ti_tid, ti.ti_lid);
253 if (process->lwpid != ti.ti_lid)
254 fatal ("PID mismatch! Expected %ld, got %ld",
255 (long) process->lwpid, (long) ti.ti_lid);
257 /* If the new thread ID is zero, a final thread ID will be available
258 later. Do not enable thread debugging yet. */
261 err = td_thr_event_enable (&th, 1);
263 error ("Cannot enable thread event reporting for %d: %s",
264 ti.ti_lid, thread_db_err_str (err));
268 /* Switch to indexing the threads list by TID. */
269 change_inferior_id (&all_threads, ti.ti_tid);
271 new_thread_notify (ti.ti_tid);
273 process->tid = ti.ti_tid;
274 process->lwpid = ti.ti_lid;
275 process->thread_known = 1;
278 err = td_thr_event_enable (&th, 1);
280 error ("Cannot enable thread event reporting for %d: %s",
281 ti.ti_lid, thread_db_err_str (err));
287 maybe_attach_thread (const td_thrhandle_t *th_p, td_thrinfo_t *ti_p)
290 struct thread_info *inferior;
291 struct process_info *process;
293 inferior = (struct thread_info *) find_inferior_id (&all_threads,
295 if (inferior != NULL)
299 fprintf (stderr, "Attaching to thread %ld (LWP %d)\n",
300 ti_p->ti_tid, ti_p->ti_lid);
301 linux_attach_lwp (ti_p->ti_lid, ti_p->ti_tid);
302 inferior = (struct thread_info *) find_inferior_id (&all_threads,
304 if (inferior == NULL)
306 warning ("Could not attach to thread %ld (LWP %d)\n",
307 ti_p->ti_tid, ti_p->ti_lid);
311 process = inferior_target_data (inferior);
313 new_thread_notify (ti_p->ti_tid);
315 process->tid = ti_p->ti_tid;
316 process->lwpid = ti_p->ti_lid;
318 process->thread_known = 1;
320 err = td_thr_event_enable (th_p, 1);
322 error ("Cannot enable thread event reporting for %d: %s",
323 ti_p->ti_lid, thread_db_err_str (err));
327 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
332 err = td_thr_get_info (th_p, &ti);
334 error ("Cannot get thread info: %s", thread_db_err_str (err));
336 /* Check for zombies. */
337 if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
340 maybe_attach_thread (th_p, &ti);
346 thread_db_find_new_threads (void)
350 /* This function is only called when we first initialize thread_db.
351 First locate the initial thread. If it is not ready for
352 debugging yet, then stop. */
353 if (find_first_thread () == 0)
356 /* Iterate over all user-space threads to discover new threads. */
357 err = td_ta_thr_iter (thread_agent, find_new_threads_callback, NULL,
358 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
359 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
361 error ("Cannot find new threads: %s", thread_db_err_str (err));
364 /* Cache all future symbols that thread_db might request. We can not
365 request symbols at arbitrary states in the remote protocol, only
366 when the client tells us that new symbols are available. So when
367 we load the thread library, make sure to check the entire list. */
370 thread_db_look_up_symbols (void)
372 const char **sym_list = td_symbol_list ();
375 for (sym_list = td_symbol_list (); *sym_list; sym_list++)
376 look_up_one_symbol (*sym_list, &unused);
380 thread_db_get_tls_address (struct thread_info *thread, CORE_ADDR offset,
381 CORE_ADDR load_module, CORE_ADDR *address)
383 #if HAVE_TD_THR_TLS_GET_ADDR
386 struct process_info *process;
388 process = get_thread_process (thread);
389 if (!process->thread_known)
390 find_first_thread ();
391 if (!process->thread_known)
394 /* Note the cast through uintptr_t: this interface only works if
395 a target address fits in a psaddr_t, which is a host pointer.
396 So a 32-bit debugger can not access 64-bit TLS through this. */
397 err = td_thr_tls_get_addr (&process->th, (psaddr_t) (uintptr_t) load_module,
401 *address = (CORE_ADDR) (uintptr_t) addr;
416 /* FIXME drow/2004-10-16: This is the "overall process ID", which
417 GNU/Linux calls tgid, "thread group ID". When we support
418 attaching to threads, the original thread may not be the correct
419 thread. We would have to get the process ID from /proc for NPTL.
420 For LinuxThreads we could do something similar: follow the chain
421 of parent processes until we find the highest one we're attached
422 to, and use its tgid.
424 This isn't the only place in gdbserver that assumes that the first
425 process in the list is the thread group leader. */
426 proc_handle.pid = ((struct inferior_list_entry *)current_inferior)->id;
428 /* Allow new symbol lookups. */
429 all_symbols_looked_up = 0;
431 err = td_ta_new (&proc_handle, &thread_agent);
435 /* No thread library was detected. */
439 /* The thread library was detected. */
441 if (thread_db_enable_reporting () == 0)
443 thread_db_find_new_threads ();
444 thread_db_look_up_symbols ();
445 all_symbols_looked_up = 1;
449 warning ("error initializing thread_db library: %s",
450 thread_db_err_str (err));