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 void thread_db_find_new_threads (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 inferior_linux_data *tdata;
139 struct thread_info *inferior;
140 struct process_info *process;
143 fprintf (stderr, "Thread creation event.\n");
145 tdata = inferior_target_data (current_inferior);
147 /* FIXME: This assumes we don't get another event.
148 In the LinuxThreads implementation, this is safe,
149 because all events come from the manager thread
150 (except for its own creation, of course). */
151 err = td_ta_event_getmsg (thread_agent, &msg);
153 fprintf (stderr, "thread getmsg err: %s\n",
154 thread_db_err_str (err));
156 /* If we do not know about the main thread yet, this would be a good time to
157 find it. We need to do this to pick up the main thread before any newly
159 inferior = (struct thread_info *) all_threads.head;
160 process = get_thread_process (inferior);
161 if (process->thread_known == 0)
162 thread_db_find_new_threads ();
164 /* msg.event == TD_EVENT_CREATE */
166 find_new_threads_callback (msg.th_p, NULL);
171 thread_db_death_event (CORE_ADDR where)
174 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 maybe_attach_thread (const td_thrhandle_t *th_p, td_thrinfo_t *ti_p)
237 struct thread_info *inferior;
238 struct process_info *process;
240 /* If we are attaching to our first thread, things are a little
242 if (all_threads.head == all_threads.tail)
244 inferior = (struct thread_info *) all_threads.head;
245 process = get_thread_process (inferior);
247 if (process->thread_known == 0)
249 /* If the new thread ID is zero, a final thread ID will be
250 available later. Do not enable thread debugging yet. */
251 if (ti_p->ti_tid == 0)
253 err = td_thr_event_enable (th_p, 1);
255 error ("Cannot enable thread event reporting for %d: %s",
256 ti_p->ti_lid, thread_db_err_str (err));
260 if (process->lwpid != ti_p->ti_lid)
261 fatal ("PID mismatch! Expected %ld, got %ld",
262 (long) process->lwpid, (long) ti_p->ti_lid);
264 /* Switch to indexing the threads list by TID. */
265 change_inferior_id (&all_threads, ti_p->ti_tid);
270 inferior = (struct thread_info *) find_inferior_id (&all_threads,
272 if (inferior != NULL)
276 fprintf (stderr, "Attaching to thread %ld (LWP %d)\n",
277 ti_p->ti_tid, ti_p->ti_lid);
278 linux_attach_lwp (ti_p->ti_lid, ti_p->ti_tid);
279 inferior = (struct thread_info *) find_inferior_id (&all_threads,
281 if (inferior == NULL)
283 warning ("Could not attach to thread %ld (LWP %d)\n",
284 ti_p->ti_tid, ti_p->ti_lid);
288 process = inferior_target_data (inferior);
291 new_thread_notify (ti_p->ti_tid);
293 process->tid = ti_p->ti_tid;
294 process->lwpid = ti_p->ti_lid;
296 process->thread_known = 1;
298 err = td_thr_event_enable (th_p, 1);
300 error ("Cannot enable thread event reporting for %d: %s",
301 ti_p->ti_lid, thread_db_err_str (err));
305 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
310 err = td_thr_get_info (th_p, &ti);
312 error ("Cannot get thread info: %s", thread_db_err_str (err));
314 /* Check for zombies. */
315 if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
318 maybe_attach_thread (th_p, &ti);
324 thread_db_find_new_threads (void)
328 /* Iterate over all user-space threads to discover new threads. */
329 err = td_ta_thr_iter (thread_agent, find_new_threads_callback, NULL,
330 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
331 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
333 error ("Cannot find new threads: %s", thread_db_err_str (err));
336 /* Cache all future symbols that thread_db might request. We can not
337 request symbols at arbitrary states in the remote protocol, only
338 when the client tells us that new symbols are available. So when
339 we load the thread library, make sure to check the entire list. */
342 thread_db_look_up_symbols (void)
344 const char **sym_list = td_symbol_list ();
347 for (sym_list = td_symbol_list (); *sym_list; sym_list++)
348 look_up_one_symbol (*sym_list, &unused);
352 thread_db_get_tls_address (struct thread_info *thread, CORE_ADDR offset,
353 CORE_ADDR load_module, CORE_ADDR *address)
355 #if HAVE_TD_THR_TLS_GET_ADDR
358 struct process_info *process;
360 process = get_thread_process (thread);
361 if (!process->thread_known)
362 thread_db_find_new_threads ();
363 if (!process->thread_known)
366 /* Note the cast through uintptr_t: this interface only works if
367 a target address fits in a psaddr_t, which is a host pointer.
368 So a 32-bit debugger can not access 64-bit TLS through this. */
369 err = td_thr_tls_get_addr (&process->th, (psaddr_t) (uintptr_t) load_module,
373 *address = (CORE_ADDR) (uintptr_t) addr;
388 /* FIXME drow/2004-10-16: This is the "overall process ID", which
389 GNU/Linux calls tgid, "thread group ID". When we support
390 attaching to threads, the original thread may not be the correct
391 thread. We would have to get the process ID from /proc for NPTL.
392 For LinuxThreads we could do something similar: follow the chain
393 of parent processes until we find the highest one we're attached
394 to, and use its tgid.
396 This isn't the only place in gdbserver that assumes that the first
397 process in the list is the thread group leader. */
398 proc_handle.pid = ((struct inferior_list_entry *)current_inferior)->id;
400 /* Allow new symbol lookups. */
401 all_symbols_looked_up = 0;
403 err = td_ta_new (&proc_handle, &thread_agent);
407 /* No thread library was detected. */
411 /* The thread library was detected. */
413 if (thread_db_enable_reporting () == 0)
415 thread_db_find_new_threads ();
416 thread_db_look_up_symbols ();
417 all_symbols_looked_up = 1;
421 warning ("error initializing thread_db library: %s",
422 thread_db_err_str (err));