1 /* Solaris threads debugging interface.
3 Copyright (C) 1996-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 /* This module implements a sort of half target that sits between the
21 machine-independent parts of GDB and the /proc interface (procfs.c)
22 to provide access to the Solaris user-mode thread implementation.
24 Solaris threads are true user-mode threads, which are invoked via
25 the thr_* and pthread_* (native and POSIX respectivly) interfaces.
26 These are mostly implemented in user-space, with all thread context
27 kept in various structures that live in the user's heap. These
28 should not be confused with lightweight processes (LWPs), which are
29 implemented by the kernel, and scheduled without explicit
30 intervention by the process.
32 Just to confuse things a little, Solaris threads (both native and
33 POSIX) are actually implemented using LWPs. In general, there are
34 going to be more threads than LWPs. There is no fixed
35 correspondence between a thread and an LWP. When a thread wants to
36 run, it gets scheduled onto the first available LWP and can
37 therefore migrate from one LWP to another as time goes on. A
38 sleeping thread may not be associated with an LWP at all!
40 To make it possible to mess with threads, Sun provides a library
41 called libthread_db.so.1 (not to be confused with
42 libthread_db.so.0, which doesn't have a published interface). This
43 interface has an upper part, which it provides, and a lower part
44 which we provide. The upper part consists of the td_* routines,
45 which allow us to find all the threads, query their state, etc...
46 The lower part consists of all of the ps_*, which are used by the
47 td_* routines to read/write memory, manipulate LWPs, lookup
48 symbols, etc... The ps_* routines actually do most of their work
49 by calling functions in procfs.c. */
53 #include <proc_service.h>
54 #include <thread_db.h>
55 #include "gdbthread.h"
72 struct target_ops sol_thread_ops
;
74 /* Prototypes for supply_gregset etc. */
77 /* This struct is defined by us, but mainly used for the proc_service
78 interface. We don't have much use for it, except as a handy place
79 to get a real PID for memory accesses. */
92 static struct ps_prochandle main_ph
;
93 static td_thragent_t
*main_ta
;
94 static int sol_thread_active
= 0;
96 static void init_sol_thread_ops (void);
98 /* Default definitions: These must be defined in tm.h if they are to
99 be shared with a process module such as procfs. */
101 /* Types of the libthread_db functions. */
103 typedef void (td_log_ftype
)(const int on_off
);
104 typedef td_err_e (td_ta_new_ftype
)(const struct ps_prochandle
*ph_p
,
105 td_thragent_t
**ta_pp
);
106 typedef td_err_e (td_ta_delete_ftype
)(td_thragent_t
*ta_p
);
107 typedef td_err_e (td_init_ftype
)(void);
108 typedef td_err_e (td_ta_get_ph_ftype
)(const td_thragent_t
*ta_p
,
109 struct ps_prochandle
**ph_pp
);
110 typedef td_err_e (td_ta_get_nthreads_ftype
)(const td_thragent_t
*ta_p
,
112 typedef td_err_e (td_ta_tsd_iter_ftype
)(const td_thragent_t
*ta_p
,
113 td_key_iter_f
*cb
, void *cbdata_p
);
114 typedef td_err_e (td_ta_thr_iter_ftype
)(const td_thragent_t
*ta_p
,
115 td_thr_iter_f
*cb
, void *cbdata_p
,
116 td_thr_state_e state
, int ti_pri
,
117 sigset_t
*ti_sigmask_p
,
118 unsigned ti_user_flags
);
119 typedef td_err_e (td_thr_validate_ftype
)(const td_thrhandle_t
*th_p
);
120 typedef td_err_e (td_thr_tsd_ftype
)(const td_thrhandle_t
* th_p
,
121 const thread_key_t key
, void **data_pp
);
122 typedef td_err_e (td_thr_get_info_ftype
)(const td_thrhandle_t
*th_p
,
124 typedef td_err_e (td_thr_getfpregs_ftype
)(const td_thrhandle_t
*th_p
,
125 prfpregset_t
*fpregset
);
126 typedef td_err_e (td_thr_getxregsize_ftype
)(const td_thrhandle_t
*th_p
,
128 typedef td_err_e (td_thr_getxregs_ftype
)(const td_thrhandle_t
*th_p
,
129 const caddr_t xregset
);
130 typedef td_err_e (td_thr_sigsetmask_ftype
)(const td_thrhandle_t
*th_p
,
131 const sigset_t ti_sigmask
);
132 typedef td_err_e (td_thr_setprio_ftype
)(const td_thrhandle_t
*th_p
,
134 typedef td_err_e (td_thr_setsigpending_ftype
)(const td_thrhandle_t
*th_p
,
135 const uchar_t ti_pending_flag
,
136 const sigset_t ti_pending
);
137 typedef td_err_e (td_thr_setfpregs_ftype
)(const td_thrhandle_t
*th_p
,
138 const prfpregset_t
*fpregset
);
139 typedef td_err_e (td_thr_setxregs_ftype
)(const td_thrhandle_t
*th_p
,
140 const caddr_t xregset
);
141 typedef td_err_e (td_ta_map_id2thr_ftype
)(const td_thragent_t
*ta_p
,
143 td_thrhandle_t
*th_p
);
144 typedef td_err_e (td_ta_map_lwp2thr_ftype
)(const td_thragent_t
*ta_p
,
146 td_thrhandle_t
*th_p
);
147 typedef td_err_e (td_thr_getgregs_ftype
)(const td_thrhandle_t
*th_p
,
149 typedef td_err_e (td_thr_setgregs_ftype
)(const td_thrhandle_t
*th_p
,
150 const prgregset_t regset
);
152 /* Pointers to routines from libthread_db resolved by dlopen(). */
154 static td_log_ftype
*p_td_log
;
155 static td_ta_new_ftype
*p_td_ta_new
;
156 static td_ta_delete_ftype
*p_td_ta_delete
;
157 static td_init_ftype
*p_td_init
;
158 static td_ta_get_ph_ftype
*p_td_ta_get_ph
;
159 static td_ta_get_nthreads_ftype
*p_td_ta_get_nthreads
;
160 static td_ta_tsd_iter_ftype
*p_td_ta_tsd_iter
;
161 static td_ta_thr_iter_ftype
*p_td_ta_thr_iter
;
162 static td_thr_validate_ftype
*p_td_thr_validate
;
163 static td_thr_tsd_ftype
*p_td_thr_tsd
;
164 static td_thr_get_info_ftype
*p_td_thr_get_info
;
165 static td_thr_getfpregs_ftype
*p_td_thr_getfpregs
;
166 static td_thr_getxregsize_ftype
*p_td_thr_getxregsize
;
167 static td_thr_getxregs_ftype
*p_td_thr_getxregs
;
168 static td_thr_sigsetmask_ftype
*p_td_thr_sigsetmask
;
169 static td_thr_setprio_ftype
*p_td_thr_setprio
;
170 static td_thr_setsigpending_ftype
*p_td_thr_setsigpending
;
171 static td_thr_setfpregs_ftype
*p_td_thr_setfpregs
;
172 static td_thr_setxregs_ftype
*p_td_thr_setxregs
;
173 static td_ta_map_id2thr_ftype
*p_td_ta_map_id2thr
;
174 static td_ta_map_lwp2thr_ftype
*p_td_ta_map_lwp2thr
;
175 static td_thr_getgregs_ftype
*p_td_thr_getgregs
;
176 static td_thr_setgregs_ftype
*p_td_thr_setgregs
;
179 /* Return the libthread_db error string associated with ERRCODE. If
180 ERRCODE is unknown, return an appropriate message. */
183 td_err_string (td_err_e errcode
)
185 static struct string_map td_err_table
[] =
187 { TD_OK
, "generic \"call succeeded\"" },
188 { TD_ERR
, "generic error." },
189 { TD_NOTHR
, "no thread can be found to satisfy query" },
190 { TD_NOSV
, "no synch. variable can be found to satisfy query" },
191 { TD_NOLWP
, "no lwp can be found to satisfy query" },
192 { TD_BADPH
, "invalid process handle" },
193 { TD_BADTH
, "invalid thread handle" },
194 { TD_BADSH
, "invalid synchronization handle" },
195 { TD_BADTA
, "invalid thread agent" },
196 { TD_BADKEY
, "invalid key" },
197 { TD_NOMSG
, "td_thr_event_getmsg() called when there was no message" },
198 { TD_NOFPREGS
, "FPU register set not available for given thread" },
199 { TD_NOLIBTHREAD
, "application not linked with libthread" },
200 { TD_NOEVENT
, "requested event is not supported" },
201 { TD_NOCAPAB
, "capability not available" },
202 { TD_DBERR
, "Debugger service failed" },
203 { TD_NOAPLIC
, "Operation not applicable to" },
204 { TD_NOTSD
, "No thread specific data for this thread" },
205 { TD_MALLOC
, "Malloc failed" },
206 { TD_PARTIALREG
, "Only part of register set was written/read" },
207 { TD_NOXREGS
, "X register set not available for given thread" }
209 const int td_err_size
= sizeof td_err_table
/ sizeof (struct string_map
);
213 for (i
= 0; i
< td_err_size
; i
++)
214 if (td_err_table
[i
].num
== errcode
)
215 return td_err_table
[i
].str
;
217 xsnprintf (buf
, sizeof (buf
), "Unknown libthread_db error code: %d",
223 /* Return the libthread_db state string assicoated with STATECODE.
224 If STATECODE is unknown, return an appropriate message. */
227 td_state_string (td_thr_state_e statecode
)
229 static struct string_map td_thr_state_table
[] =
231 { TD_THR_ANY_STATE
, "any state" },
232 { TD_THR_UNKNOWN
, "unknown" },
233 { TD_THR_STOPPED
, "stopped" },
234 { TD_THR_RUN
, "run" },
235 { TD_THR_ACTIVE
, "active" },
236 { TD_THR_ZOMBIE
, "zombie" },
237 { TD_THR_SLEEP
, "sleep" },
238 { TD_THR_STOPPED_ASLEEP
, "stopped asleep" }
240 const int td_thr_state_table_size
=
241 sizeof td_thr_state_table
/ sizeof (struct string_map
);
245 for (i
= 0; i
< td_thr_state_table_size
; i
++)
246 if (td_thr_state_table
[i
].num
== statecode
)
247 return td_thr_state_table
[i
].str
;
249 xsnprintf (buf
, sizeof (buf
), "Unknown libthread_db state code: %d",
256 /* Convert a POSIX or Solaris thread ID into a LWP ID. If THREAD_ID
257 doesn't exist, that's an error. If it's an inactive thread, return
260 NOTE: This function probably shouldn't call error(). */
263 thread_to_lwp (ptid_t thread_id
, int default_lwp
)
269 if (ptid_lwp_p (thread_id
))
270 return thread_id
; /* It's already an LWP ID. */
272 /* It's a thread. Convert to LWP. */
274 val
= p_td_ta_map_id2thr (main_ta
, ptid_get_tid (thread_id
), &th
);
276 return pid_to_ptid (-1); /* Thread must have terminated. */
277 else if (val
!= TD_OK
)
278 error (_("thread_to_lwp: td_ta_map_id2thr %s"), td_err_string (val
));
280 val
= p_td_thr_get_info (&th
, &ti
);
282 return pid_to_ptid (-1); /* Thread must have terminated. */
283 else if (val
!= TD_OK
)
284 error (_("thread_to_lwp: td_thr_get_info: %s"), td_err_string (val
));
286 if (ti
.ti_state
!= TD_THR_ACTIVE
)
288 if (default_lwp
!= -1)
289 return pid_to_ptid (default_lwp
);
290 error (_("thread_to_lwp: thread state not active: %s"),
291 td_state_string (ti
.ti_state
));
294 return ptid_build (ptid_get_pid (thread_id
), ti
.ti_lid
, 0);
297 /* Convert an LWP ID into a POSIX or Solaris thread ID. If LWP_ID
298 doesn't exists, that's an error.
300 NOTE: This function probably shouldn't call error(). */
303 lwp_to_thread (ptid_t lwp
)
309 if (ptid_tid_p (lwp
))
310 return lwp
; /* It's already a thread ID. */
312 /* It's an LWP. Convert it to a thread ID. */
314 if (!target_thread_alive (lwp
))
315 return pid_to_ptid (-1); /* Must be a defunct LPW. */
317 val
= p_td_ta_map_lwp2thr (main_ta
, ptid_get_lwp (lwp
), &th
);
319 return pid_to_ptid (-1); /* Thread must have terminated. */
320 else if (val
!= TD_OK
)
321 error (_("lwp_to_thread: td_ta_map_lwp2thr: %s."), td_err_string (val
));
323 val
= p_td_thr_validate (&th
);
325 return lwp
; /* Unknown to libthread; just return LPW, */
326 else if (val
!= TD_OK
)
327 error (_("lwp_to_thread: td_thr_validate: %s."), td_err_string (val
));
329 val
= p_td_thr_get_info (&th
, &ti
);
331 return pid_to_ptid (-1); /* Thread must have terminated. */
332 else if (val
!= TD_OK
)
333 error (_("lwp_to_thread: td_thr_get_info: %s."), td_err_string (val
));
335 return ptid_build (ptid_get_pid (lwp
), 0 , ti
.ti_tid
);
339 /* Most target vector functions from here on actually just pass
340 through to the layer beneath, as they don't need to do anything
341 specific for threads. */
343 /* Take a program previously attached to and detaches it. The program
344 resumes execution and will no longer stop on signals, etc. We'd
345 better not have left any breakpoints in the program or it'll die
346 when it hits one. For this to work, it may be necessary for the
347 process to have been previously attached. It *might* work if the
348 program was started via the normal ptrace (PTRACE_TRACEME). */
351 sol_thread_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
353 struct target_ops
*beneath
= find_target_beneath (ops
);
355 sol_thread_active
= 0;
356 inferior_ptid
= pid_to_ptid (ptid_get_pid (main_ph
.ptid
));
358 beneath
->to_detach (beneath
, args
, from_tty
);
361 /* Resume execution of process PTID. If STEP is nozero, then just
362 single step it. If SIGNAL is nonzero, restart it with that signal
363 activated. We may have to convert PTID from a thread ID to an LWP
367 sol_thread_resume (struct target_ops
*ops
,
368 ptid_t ptid
, int step
, enum gdb_signal signo
)
370 struct cleanup
*old_chain
;
371 struct target_ops
*beneath
= find_target_beneath (ops
);
373 old_chain
= save_inferior_ptid ();
375 inferior_ptid
= thread_to_lwp (inferior_ptid
, ptid_get_pid (main_ph
.ptid
));
376 if (ptid_get_pid (inferior_ptid
) == -1)
377 inferior_ptid
= procfs_first_available ();
379 if (ptid_get_pid (ptid
) != -1)
381 ptid_t save_ptid
= ptid
;
383 ptid
= thread_to_lwp (ptid
, -2);
384 if (ptid_get_pid (ptid
) == -2) /* Inactive thread. */
385 error (_("This version of Solaris can't start inactive threads."));
386 if (info_verbose
&& ptid_get_pid (ptid
) == -1)
387 warning (_("Specified thread %ld seems to have terminated"),
388 ptid_get_tid (save_ptid
));
391 beneath
->to_resume (beneath
, ptid
, step
, signo
);
393 do_cleanups (old_chain
);
396 /* Wait for any threads to stop. We may have to convert PTID from a
397 thread ID to an LWP ID, and vice versa on the way out. */
400 sol_thread_wait (struct target_ops
*ops
,
401 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
405 struct target_ops
*beneath
= find_target_beneath (ops
);
406 struct cleanup
*old_chain
;
408 save_ptid
= inferior_ptid
;
409 old_chain
= save_inferior_ptid ();
411 inferior_ptid
= thread_to_lwp (inferior_ptid
, ptid_get_pid (main_ph
.ptid
));
412 if (ptid_get_pid (inferior_ptid
) == -1)
413 inferior_ptid
= procfs_first_available ();
415 if (ptid_get_pid (ptid
) != -1)
417 ptid_t save_ptid
= ptid
;
419 ptid
= thread_to_lwp (ptid
, -2);
420 if (ptid_get_pid (ptid
) == -2) /* Inactive thread. */
421 error (_("This version of Solaris can't start inactive threads."));
422 if (info_verbose
&& ptid_get_pid (ptid
) == -1)
423 warning (_("Specified thread %ld seems to have terminated"),
424 ptid_get_tid (save_ptid
));
427 rtnval
= beneath
->to_wait (beneath
, ptid
, ourstatus
, options
);
429 if (ourstatus
->kind
!= TARGET_WAITKIND_EXITED
)
431 /* Map the LWP of interest back to the appropriate thread ID. */
432 rtnval
= lwp_to_thread (rtnval
);
433 if (ptid_get_pid (rtnval
) == -1)
436 /* See if we have a new thread. */
437 if (ptid_tid_p (rtnval
)
438 && !ptid_equal (rtnval
, save_ptid
)
439 && (!in_thread_list (rtnval
)
440 || is_exited (rtnval
)))
444 /* During process initialization, we may get here without the thread
445 package being initialized, since that can only happen after we've
446 found the shared libs. */
448 do_cleanups (old_chain
);
454 sol_thread_fetch_registers (struct target_ops
*ops
,
455 struct regcache
*regcache
, int regnum
)
458 td_thrhandle_t thandle
;
461 prfpregset_t fpregset
;
462 gdb_gregset_t
*gregset_p
= &gregset
;
463 gdb_fpregset_t
*fpregset_p
= &fpregset
;
464 struct target_ops
*beneath
= find_target_beneath (ops
);
465 ptid_t ptid
= regcache_get_ptid (regcache
);
467 if (!ptid_tid_p (ptid
))
469 /* It's an LWP; pass the request on to the layer beneath. */
470 beneath
->to_fetch_registers (beneath
, regcache
, regnum
);
474 /* Solaris thread: convert PTID into a td_thrhandle_t. */
475 thread
= ptid_get_tid (ptid
);
477 error (_("sol_thread_fetch_registers: thread == 0"));
479 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
481 error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"),
482 td_err_string (val
));
484 /* Get the general-purpose registers. */
486 val
= p_td_thr_getgregs (&thandle
, gregset
);
487 if (val
!= TD_OK
&& val
!= TD_PARTIALREG
)
488 error (_("sol_thread_fetch_registers: td_thr_getgregs %s"),
489 td_err_string (val
));
491 /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
492 and %sp are saved (by a thread context switch). */
494 /* And, now the floating-point registers. */
496 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
497 if (val
!= TD_OK
&& val
!= TD_NOFPREGS
)
498 error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"),
499 td_err_string (val
));
501 /* Note that we must call supply_gregset and supply_fpregset *after*
502 calling the td routines because the td routines call ps_lget*
503 which affect the values stored in the registers array. */
505 supply_gregset (regcache
, (const gdb_gregset_t
*) gregset_p
);
506 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregset_p
);
510 sol_thread_store_registers (struct target_ops
*ops
,
511 struct regcache
*regcache
, int regnum
)
514 td_thrhandle_t thandle
;
517 prfpregset_t fpregset
;
518 ptid_t ptid
= regcache_get_ptid (regcache
);
520 if (!ptid_tid_p (ptid
))
522 struct target_ops
*beneath
= find_target_beneath (ops
);
524 /* It's an LWP; pass the request on to the layer beneath. */
525 beneath
->to_store_registers (beneath
, regcache
, regnum
);
529 /* Solaris thread: convert PTID into a td_thrhandle_t. */
530 thread
= ptid_get_tid (ptid
);
532 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
534 error (_("sol_thread_store_registers: td_ta_map_id2thr %s"),
535 td_err_string (val
));
539 /* Not writing all the registers. */
540 char old_value
[MAX_REGISTER_SIZE
];
542 /* Save new register value. */
543 regcache_raw_collect (regcache
, regnum
, old_value
);
545 val
= p_td_thr_getgregs (&thandle
, gregset
);
547 error (_("sol_thread_store_registers: td_thr_getgregs %s"),
548 td_err_string (val
));
549 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
551 error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
552 td_err_string (val
));
554 /* Restore new register value. */
555 regcache_raw_supply (regcache
, regnum
, old_value
);
558 fill_gregset (regcache
, (gdb_gregset_t
*) &gregset
, regnum
);
559 fill_fpregset (regcache
, (gdb_fpregset_t
*) &fpregset
, regnum
);
561 val
= p_td_thr_setgregs (&thandle
, gregset
);
563 error (_("sol_thread_store_registers: td_thr_setgregs %s"),
564 td_err_string (val
));
565 val
= p_td_thr_setfpregs (&thandle
, &fpregset
);
567 error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
568 td_err_string (val
));
571 /* Perform partial transfers on OBJECT. See target_read_partial and
572 target_write_partial for details of each variant. One, and only
573 one, of readbuf or writebuf must be non-NULL. */
575 static enum target_xfer_status
576 sol_thread_xfer_partial (struct target_ops
*ops
, enum target_object object
,
577 const char *annex
, gdb_byte
*readbuf
,
578 const gdb_byte
*writebuf
,
579 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
581 enum target_xfer_status retval
;
582 struct cleanup
*old_chain
;
583 struct target_ops
*beneath
= find_target_beneath (ops
);
585 old_chain
= save_inferior_ptid ();
587 if (ptid_tid_p (inferior_ptid
) || !target_thread_alive (inferior_ptid
))
589 /* It's either a thread or an LWP that isn't alive. Any live
590 LWP will do so use the first available.
592 NOTE: We don't need to call switch_to_thread; we're just
594 inferior_ptid
= procfs_first_available ();
597 retval
= beneath
->to_xfer_partial (beneath
, object
, annex
, readbuf
,
598 writebuf
, offset
, len
, xfered_len
);
600 do_cleanups (old_chain
);
606 check_for_thread_db (void)
611 /* Don't attempt to use thread_db for remote targets. */
612 if (!(target_can_run (¤t_target
) || core_bfd
))
615 /* Do nothing if we couldn't load libthread_db.so.1. */
616 if (p_td_ta_new
== NULL
)
619 if (sol_thread_active
)
620 /* Nothing to do. The thread library was already detected and the
621 target vector was already activated. */
624 /* Now, initialize libthread_db. This needs to be done after the
625 shared libraries are located because it needs information from
626 the user's thread library. */
631 warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (err
));
635 /* Now attempt to open a connection to the thread library. */
636 err
= p_td_ta_new (&main_ph
, &main_ta
);
640 /* No thread library was detected. */
644 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
646 /* The thread library was detected. Activate the sol_thread target. */
647 push_target (&sol_thread_ops
);
648 sol_thread_active
= 1;
650 main_ph
.ptid
= inferior_ptid
; /* Save for xfer_memory. */
651 ptid
= lwp_to_thread (inferior_ptid
);
652 if (ptid_get_pid (ptid
) != -1)
653 inferior_ptid
= ptid
;
655 target_update_thread_list ();
659 warning (_("Cannot initialize thread debugging library: %s"),
660 td_err_string (err
));
665 /* This routine is called whenever a new symbol table is read in, or
666 when all symbol tables are removed. libthread_db can only be
667 initialized when it finds the right variables in libthread.so.
668 Since it's a shared library, those variables don't show up until
669 the library gets mapped and the symbol table is read in. */
672 sol_thread_new_objfile (struct objfile
*objfile
)
675 check_for_thread_db ();
678 /* Clean up after the inferior dies. */
681 sol_thread_mourn_inferior (struct target_ops
*ops
)
683 struct target_ops
*beneath
= find_target_beneath (ops
);
685 sol_thread_active
= 0;
689 beneath
->to_mourn_inferior (beneath
);
692 /* Return true if PTID is still active in the inferior. */
695 sol_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
697 if (ptid_tid_p (ptid
))
699 /* It's a (user-level) thread. */
704 pid
= ptid_get_tid (ptid
);
705 if ((val
= p_td_ta_map_id2thr (main_ta
, pid
, &th
)) != TD_OK
)
706 return 0; /* Thread not found. */
707 if ((val
= p_td_thr_validate (&th
)) != TD_OK
)
708 return 0; /* Thread not valid. */
709 return 1; /* Known thread. */
713 struct target_ops
*beneath
= find_target_beneath (ops
);
715 /* It's an LPW; pass the request on to the layer below. */
716 return beneath
->to_thread_alive (beneath
, ptid
);
721 /* These routines implement the lower half of the thread_db interface,
722 i.e. the ps_* routines. */
724 /* Various versions of <proc_service.h> have slightly different
725 function prototypes. In particular, we have
728 struct ps_prochandle * const struct ps_prochandle *
733 Which one you have depends on the Solaris version and what patches
734 you've applied. On the theory that there are only two major
735 variants, we have configure check the prototype of ps_pdwrite (),
736 and use that info to make appropriate typedefs here. */
738 #ifdef PROC_SERVICE_IS_OLD
739 typedef const struct ps_prochandle
*gdb_ps_prochandle_t
;
740 typedef char *gdb_ps_read_buf_t
;
741 typedef char *gdb_ps_write_buf_t
;
742 typedef int gdb_ps_size_t
;
743 typedef psaddr_t gdb_ps_addr_t
;
745 typedef struct ps_prochandle
*gdb_ps_prochandle_t
;
746 typedef void *gdb_ps_read_buf_t
;
747 typedef const void *gdb_ps_write_buf_t
;
748 typedef size_t gdb_ps_size_t
;
749 typedef psaddr_t gdb_ps_addr_t
;
752 /* The next four routines are called by libthread_db to tell us to
753 stop and stop a particular process or lwp. Since GDB ensures that
754 these are all stopped by the time we call anything in thread_db,
755 these routines need to do nothing. */
760 ps_pstop (gdb_ps_prochandle_t ph
)
765 /* Process continue. */
768 ps_pcontinue (gdb_ps_prochandle_t ph
)
776 ps_lstop (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
784 ps_lcontinue (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
789 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
792 ps_pglobal_lookup (gdb_ps_prochandle_t ph
, const char *ld_object_name
,
793 const char *ld_symbol_name
, gdb_ps_addr_t
*ld_symbol_addr
)
795 struct bound_minimal_symbol ms
;
797 ms
= lookup_minimal_symbol (ld_symbol_name
, NULL
, NULL
);
801 *ld_symbol_addr
= BMSYMBOL_VALUE_ADDRESS (ms
);
805 /* Common routine for reading and writing memory. */
808 rw_common (int dowrite
, const struct ps_prochandle
*ph
, gdb_ps_addr_t addr
,
809 gdb_byte
*buf
, int size
)
812 struct cleanup
*old_chain
;
814 old_chain
= save_inferior_ptid ();
816 if (ptid_tid_p (inferior_ptid
) || !target_thread_alive (inferior_ptid
))
818 /* It's either a thread or an LWP that isn't alive. Any live
819 LWP will do so use the first available.
821 NOTE: We don't need to call switch_to_thread; we're just
823 inferior_ptid
= procfs_first_available ();
826 #if defined (__sparcv9)
827 /* For Sparc64 cross Sparc32, make sure the address has not been
828 accidentally sign-extended (or whatever) to beyond 32 bits. */
829 if (bfd_get_arch_size (exec_bfd
) == 32)
834 ret
= target_write_memory (addr
, (gdb_byte
*) buf
, size
);
836 ret
= target_read_memory (addr
, (gdb_byte
*) buf
, size
);
838 do_cleanups (old_chain
);
840 return (ret
== 0 ? PS_OK
: PS_ERR
);
843 /* Copies SIZE bytes from target process .data segment to debugger memory. */
846 ps_pdread (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
847 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
849 return rw_common (0, ph
, addr
, (gdb_byte
*) buf
, size
);
852 /* Copies SIZE bytes from debugger memory .data segment to target process. */
855 ps_pdwrite (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
856 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
858 return rw_common (1, ph
, addr
, (gdb_byte
*) buf
, size
);
861 /* Copies SIZE bytes from target process .text segment to debugger memory. */
864 ps_ptread (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
865 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
867 return rw_common (0, ph
, addr
, (gdb_byte
*) buf
, size
);
870 /* Copies SIZE bytes from debugger memory .text segment to target process. */
873 ps_ptwrite (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
874 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
876 return rw_common (1, ph
, addr
, (gdb_byte
*) buf
, size
);
879 /* Get general-purpose registers for LWP. */
882 ps_lgetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, prgregset_t gregset
)
884 struct cleanup
*old_chain
;
885 struct regcache
*regcache
;
887 old_chain
= save_inferior_ptid ();
889 inferior_ptid
= ptid_build (ptid_get_pid (inferior_ptid
), lwpid
, 0);
890 regcache
= get_thread_arch_regcache (inferior_ptid
, target_gdbarch ());
892 target_fetch_registers (regcache
, -1);
893 fill_gregset (regcache
, (gdb_gregset_t
*) gregset
, -1);
895 do_cleanups (old_chain
);
900 /* Set general-purpose registers for LWP. */
903 ps_lsetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
904 const prgregset_t gregset
)
906 struct cleanup
*old_chain
;
907 struct regcache
*regcache
;
909 old_chain
= save_inferior_ptid ();
911 inferior_ptid
= ptid_build (ptid_get_pid (inferior_ptid
), lwpid
, 0);
912 regcache
= get_thread_arch_regcache (inferior_ptid
, target_gdbarch ());
914 supply_gregset (regcache
, (const gdb_gregset_t
*) gregset
);
915 target_store_registers (regcache
, -1);
917 do_cleanups (old_chain
);
922 /* Log a message (sends to gdb_stderr). */
925 ps_plog (const char *fmt
, ...)
929 va_start (args
, fmt
);
931 vfprintf_filtered (gdb_stderr
, fmt
, args
);
934 /* Get size of extra register set. Currently a noop. */
937 ps_lgetxregsize (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, int *xregsize
)
942 /* Get extra register set. Currently a noop. */
945 ps_lgetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
950 /* Set extra register set. Currently a noop. */
953 ps_lsetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
958 /* Get floating-point registers for LWP. */
961 ps_lgetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
962 prfpregset_t
*fpregset
)
964 struct cleanup
*old_chain
;
965 struct regcache
*regcache
;
967 old_chain
= save_inferior_ptid ();
969 inferior_ptid
= ptid_build (ptid_get_pid (inferior_ptid
), lwpid
, 0);
970 regcache
= get_thread_arch_regcache (inferior_ptid
, target_gdbarch ());
972 target_fetch_registers (regcache
, -1);
973 fill_fpregset (regcache
, (gdb_fpregset_t
*) fpregset
, -1);
975 do_cleanups (old_chain
);
980 /* Set floating-point regs for LWP. */
983 ps_lsetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
984 const prfpregset_t
* fpregset
)
986 struct cleanup
*old_chain
;
987 struct regcache
*regcache
;
989 old_chain
= save_inferior_ptid ();
991 inferior_ptid
= ptid_build (ptid_get_pid (inferior_ptid
), lwpid
, 0);
992 regcache
= get_thread_arch_regcache (inferior_ptid
, target_gdbarch ());
994 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregset
);
995 target_store_registers (regcache
, -1);
997 do_cleanups (old_chain
);
1002 #ifdef PR_MODEL_LP64
1003 /* Identify process as 32-bit or 64-bit. At the moment we're using
1004 BFD to do this. There might be a more Solaris-specific
1005 (e.g. procfs) method, but this ought to work. */
1008 ps_pdmodel (gdb_ps_prochandle_t ph
, int *data_model
)
1011 *data_model
= PR_MODEL_UNKNOWN
;
1012 else if (bfd_get_arch_size (exec_bfd
) == 32)
1013 *data_model
= PR_MODEL_ILP32
;
1015 *data_model
= PR_MODEL_LP64
;
1019 #endif /* PR_MODEL_LP64 */
1021 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
1023 /* Reads the local descriptor table of a LWP.
1025 This function is necessary on x86-solaris only. Without it, the loading
1026 of libthread_db would fail because of ps_lgetLDT being undefined. */
1029 ps_lgetLDT (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1032 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */
1035 /* FIXME: can't I get the process ID from the prochandle or
1038 if (ptid_get_pid (inferior_ptid
) <= 0 || lwpid
<= 0)
1041 ret
= procfs_find_LDT_entry (ptid_build (ptid_get_pid (inferior_ptid
),
1045 memcpy (pldt
, ret
, sizeof (struct ssd
));
1049 /* LDT not found. */
1055 /* Convert PTID to printable form. */
1058 solaris_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1060 static char buf
[100];
1062 if (ptid_tid_p (ptid
))
1066 lwp
= thread_to_lwp (ptid
, -2);
1068 if (ptid_get_pid (lwp
) == -1)
1069 xsnprintf (buf
, sizeof (buf
), "Thread %ld (defunct)",
1070 ptid_get_tid (ptid
));
1071 else if (ptid_get_pid (lwp
) != -2)
1072 xsnprintf (buf
, sizeof (buf
), "Thread %ld (LWP %ld)",
1073 ptid_get_tid (ptid
), ptid_get_lwp (lwp
));
1075 xsnprintf (buf
, sizeof (buf
), "Thread %ld ",
1076 ptid_get_tid (ptid
));
1078 else if (ptid_get_lwp (ptid
) != 0)
1079 xsnprintf (buf
, sizeof (buf
), "LWP %ld ", ptid_get_lwp (ptid
));
1081 xsnprintf (buf
, sizeof (buf
), "process %d ", ptid_get_pid (ptid
));
1087 /* Worker bee for update_thread_list. Callback function that gets
1088 called once per user-level thread (i.e. not for LWP's). */
1091 sol_update_thread_list_callback (const td_thrhandle_t
*th
, void *ignored
)
1097 retval
= p_td_thr_get_info (th
, &ti
);
1098 if (retval
!= TD_OK
)
1101 ptid
= ptid_build (ptid_get_pid (inferior_ptid
), 0, ti
.ti_tid
);
1102 if (!in_thread_list (ptid
) || is_exited (ptid
))
1109 sol_update_thread_list (struct target_ops
*ops
)
1111 struct target_ops
*beneath
= find_target_beneath (ops
);
1113 /* Delete dead threads. */
1116 /* Find any new LWP's. */
1117 beneath
->to_update_thread_list (beneath
);
1119 /* Then find any new user-level threads. */
1120 p_td_ta_thr_iter (main_ta
, sol_update_thread_list_callback
, (void *) 0,
1121 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1122 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1125 /* Worker bee for the "info sol-thread" command. This is a callback
1126 function that gets called once for each Solaris user-level thread
1127 (i.e. not for LWPs) in the inferior. Print anything interesting
1128 that we can think of. */
1131 info_cb (const td_thrhandle_t
*th
, void *s
)
1136 ret
= p_td_thr_get_info (th
, &ti
);
1139 printf_filtered ("%s thread #%d, lwp %d, ",
1140 ti
.ti_type
== TD_THR_SYSTEM
? "system" : "user ",
1141 ti
.ti_tid
, ti
.ti_lid
);
1142 switch (ti
.ti_state
)
1145 case TD_THR_UNKNOWN
:
1146 printf_filtered ("<unknown state>");
1148 case TD_THR_STOPPED
:
1149 printf_filtered ("(stopped)");
1152 printf_filtered ("(run) ");
1155 printf_filtered ("(active) ");
1158 printf_filtered ("(zombie) ");
1161 printf_filtered ("(asleep) ");
1163 case TD_THR_STOPPED_ASLEEP
:
1164 printf_filtered ("(stopped asleep)");
1167 /* Print thr_create start function. */
1168 if (ti
.ti_startfunc
!= 0)
1170 const struct bound_minimal_symbol msym
1171 = lookup_minimal_symbol_by_pc (ti
.ti_startfunc
);
1173 printf_filtered (" startfunc=%s",
1175 ? MSYMBOL_PRINT_NAME (msym
.minsym
)
1176 : paddress (target_gdbarch (), ti
.ti_startfunc
));
1179 /* If thread is asleep, print function that went to sleep. */
1180 if (ti
.ti_state
== TD_THR_SLEEP
)
1182 const struct bound_minimal_symbol msym
1183 = lookup_minimal_symbol_by_pc (ti
.ti_pc
);
1185 printf_filtered (" sleepfunc=%s",
1187 ? MSYMBOL_PRINT_NAME (msym
.minsym
)
1188 : paddress (target_gdbarch (), ti
.ti_pc
));
1191 printf_filtered ("\n");
1194 warning (_("info sol-thread: failed to get info for thread."));
1199 /* List some state about each Solaris user-level thread in the
1203 info_solthreads (char *args
, int from_tty
)
1205 p_td_ta_thr_iter (main_ta
, info_cb
, args
,
1206 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1207 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1210 /* Callback routine used to find a thread based on the TID part of
1214 thread_db_find_thread_from_tid (struct thread_info
*thread
, void *data
)
1216 long *tid
= (long *) data
;
1218 if (ptid_get_tid (thread
->ptid
) == *tid
)
1225 sol_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
1227 struct thread_info
*thread_info
=
1228 iterate_over_threads (thread_db_find_thread_from_tid
, &thread
);
1230 if (thread_info
== NULL
)
1232 /* The list of threads is probably not up to date. Find any
1233 thread that is missing from the list, and try again. */
1234 sol_update_thread_list (¤t_target
);
1235 thread_info
= iterate_over_threads (thread_db_find_thread_from_tid
,
1239 gdb_assert (thread_info
!= NULL
);
1241 return (thread_info
->ptid
);
1245 init_sol_thread_ops (void)
1247 sol_thread_ops
.to_shortname
= "solaris-threads";
1248 sol_thread_ops
.to_longname
= "Solaris threads and pthread.";
1249 sol_thread_ops
.to_doc
= "Solaris threads and pthread support.";
1250 sol_thread_ops
.to_detach
= sol_thread_detach
;
1251 sol_thread_ops
.to_resume
= sol_thread_resume
;
1252 sol_thread_ops
.to_wait
= sol_thread_wait
;
1253 sol_thread_ops
.to_fetch_registers
= sol_thread_fetch_registers
;
1254 sol_thread_ops
.to_store_registers
= sol_thread_store_registers
;
1255 sol_thread_ops
.to_xfer_partial
= sol_thread_xfer_partial
;
1256 sol_thread_ops
.to_mourn_inferior
= sol_thread_mourn_inferior
;
1257 sol_thread_ops
.to_thread_alive
= sol_thread_alive
;
1258 sol_thread_ops
.to_pid_to_str
= solaris_pid_to_str
;
1259 sol_thread_ops
.to_update_thread_list
= sol_update_thread_list
;
1260 sol_thread_ops
.to_stratum
= thread_stratum
;
1261 sol_thread_ops
.to_get_ada_task_ptid
= sol_get_ada_task_ptid
;
1262 sol_thread_ops
.to_magic
= OPS_MAGIC
;
1265 /* Silence -Wmissing-prototypes. */
1266 extern void _initialize_sol_thread (void);
1269 _initialize_sol_thread (void)
1273 init_sol_thread_ops ();
1275 dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
);
1279 #define resolve(X) \
1280 if (!(p_##X = (X ## _ftype *) dlsym (dlhandle, #X))) \
1284 resolve (td_ta_new
);
1285 resolve (td_ta_delete
);
1287 resolve (td_ta_get_ph
);
1288 resolve (td_ta_get_nthreads
);
1289 resolve (td_ta_tsd_iter
);
1290 resolve (td_ta_thr_iter
);
1291 resolve (td_thr_validate
);
1292 resolve (td_thr_tsd
);
1293 resolve (td_thr_get_info
);
1294 resolve (td_thr_getfpregs
);
1295 resolve (td_thr_getxregsize
);
1296 resolve (td_thr_getxregs
);
1297 resolve (td_thr_sigsetmask
);
1298 resolve (td_thr_setprio
);
1299 resolve (td_thr_setsigpending
);
1300 resolve (td_thr_setfpregs
);
1301 resolve (td_thr_setxregs
);
1302 resolve (td_ta_map_id2thr
);
1303 resolve (td_ta_map_lwp2thr
);
1304 resolve (td_thr_getgregs
);
1305 resolve (td_thr_setgregs
);
1307 complete_target_initialization (&sol_thread_ops
);
1309 add_cmd ("sol-threads", class_maintenance
, info_solthreads
,
1310 _("Show info on Solaris user threads."), &maintenanceinfolist
);
1312 /* Hook into new_objfile notification. */
1313 observer_attach_new_objfile (sol_thread_new_objfile
);
1317 fprintf_unfiltered (gdb_stderr
, "\
1318 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ());