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 val
= p_td_thr_getgregs (&thandle
, gregset
);
541 error (_("sol_thread_store_registers: td_thr_getgregs %s"),
542 td_err_string (val
));
543 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
545 error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
546 td_err_string (val
));
549 fill_gregset (regcache
, (gdb_gregset_t
*) &gregset
, regnum
);
550 fill_fpregset (regcache
, (gdb_fpregset_t
*) &fpregset
, regnum
);
552 val
= p_td_thr_setgregs (&thandle
, gregset
);
554 error (_("sol_thread_store_registers: td_thr_setgregs %s"),
555 td_err_string (val
));
556 val
= p_td_thr_setfpregs (&thandle
, &fpregset
);
558 error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
559 td_err_string (val
));
562 /* Perform partial transfers on OBJECT. See target_read_partial and
563 target_write_partial for details of each variant. One, and only
564 one, of readbuf or writebuf must be non-NULL. */
566 static enum target_xfer_status
567 sol_thread_xfer_partial (struct target_ops
*ops
, enum target_object object
,
568 const char *annex
, gdb_byte
*readbuf
,
569 const gdb_byte
*writebuf
,
570 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
572 enum target_xfer_status retval
;
573 struct cleanup
*old_chain
;
574 struct target_ops
*beneath
= find_target_beneath (ops
);
576 old_chain
= save_inferior_ptid ();
578 if (ptid_tid_p (inferior_ptid
) || !target_thread_alive (inferior_ptid
))
580 /* It's either a thread or an LWP that isn't alive. Any live
581 LWP will do so use the first available.
583 NOTE: We don't need to call switch_to_thread; we're just
585 inferior_ptid
= procfs_first_available ();
588 retval
= beneath
->to_xfer_partial (beneath
, object
, annex
, readbuf
,
589 writebuf
, offset
, len
, xfered_len
);
591 do_cleanups (old_chain
);
597 check_for_thread_db (void)
602 /* Don't attempt to use thread_db for remote targets. */
603 if (!(target_can_run (¤t_target
) || core_bfd
))
606 /* Do nothing if we couldn't load libthread_db.so.1. */
607 if (p_td_ta_new
== NULL
)
610 if (sol_thread_active
)
611 /* Nothing to do. The thread library was already detected and the
612 target vector was already activated. */
615 /* Now, initialize libthread_db. This needs to be done after the
616 shared libraries are located because it needs information from
617 the user's thread library. */
622 warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (err
));
626 /* Now attempt to open a connection to the thread library. */
627 err
= p_td_ta_new (&main_ph
, &main_ta
);
631 /* No thread library was detected. */
635 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
637 /* The thread library was detected. Activate the sol_thread target. */
638 push_target (&sol_thread_ops
);
639 sol_thread_active
= 1;
641 main_ph
.ptid
= inferior_ptid
; /* Save for xfer_memory. */
642 ptid
= lwp_to_thread (inferior_ptid
);
643 if (ptid_get_pid (ptid
) != -1)
644 inferior_ptid
= ptid
;
646 target_update_thread_list ();
650 warning (_("Cannot initialize thread debugging library: %s"),
651 td_err_string (err
));
656 /* This routine is called whenever a new symbol table is read in, or
657 when all symbol tables are removed. libthread_db can only be
658 initialized when it finds the right variables in libthread.so.
659 Since it's a shared library, those variables don't show up until
660 the library gets mapped and the symbol table is read in. */
663 sol_thread_new_objfile (struct objfile
*objfile
)
666 check_for_thread_db ();
669 /* Clean up after the inferior dies. */
672 sol_thread_mourn_inferior (struct target_ops
*ops
)
674 struct target_ops
*beneath
= find_target_beneath (ops
);
676 sol_thread_active
= 0;
680 beneath
->to_mourn_inferior (beneath
);
683 /* Return true if PTID is still active in the inferior. */
686 sol_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
688 if (ptid_tid_p (ptid
))
690 /* It's a (user-level) thread. */
695 pid
= ptid_get_tid (ptid
);
696 if ((val
= p_td_ta_map_id2thr (main_ta
, pid
, &th
)) != TD_OK
)
697 return 0; /* Thread not found. */
698 if ((val
= p_td_thr_validate (&th
)) != TD_OK
)
699 return 0; /* Thread not valid. */
700 return 1; /* Known thread. */
704 struct target_ops
*beneath
= find_target_beneath (ops
);
706 /* It's an LPW; pass the request on to the layer below. */
707 return beneath
->to_thread_alive (beneath
, ptid
);
712 /* These routines implement the lower half of the thread_db interface,
713 i.e. the ps_* routines. */
715 /* Various versions of <proc_service.h> have slightly different
716 function prototypes. In particular, we have
719 struct ps_prochandle * const struct ps_prochandle *
724 Which one you have depends on the Solaris version and what patches
725 you've applied. On the theory that there are only two major
726 variants, we have configure check the prototype of ps_pdwrite (),
727 and use that info to make appropriate typedefs here. */
729 #ifdef PROC_SERVICE_IS_OLD
730 typedef const struct ps_prochandle
*gdb_ps_prochandle_t
;
731 typedef char *gdb_ps_read_buf_t
;
732 typedef char *gdb_ps_write_buf_t
;
733 typedef int gdb_ps_size_t
;
734 typedef psaddr_t gdb_ps_addr_t
;
736 typedef struct ps_prochandle
*gdb_ps_prochandle_t
;
737 typedef void *gdb_ps_read_buf_t
;
738 typedef const void *gdb_ps_write_buf_t
;
739 typedef size_t gdb_ps_size_t
;
740 typedef psaddr_t gdb_ps_addr_t
;
743 /* The next four routines are called by libthread_db to tell us to
744 stop and stop a particular process or lwp. Since GDB ensures that
745 these are all stopped by the time we call anything in thread_db,
746 these routines need to do nothing. */
751 ps_pstop (gdb_ps_prochandle_t ph
)
756 /* Process continue. */
759 ps_pcontinue (gdb_ps_prochandle_t ph
)
767 ps_lstop (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
775 ps_lcontinue (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
780 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
783 ps_pglobal_lookup (gdb_ps_prochandle_t ph
, const char *ld_object_name
,
784 const char *ld_symbol_name
, gdb_ps_addr_t
*ld_symbol_addr
)
786 struct bound_minimal_symbol ms
;
788 ms
= lookup_minimal_symbol (ld_symbol_name
, NULL
, NULL
);
792 *ld_symbol_addr
= BMSYMBOL_VALUE_ADDRESS (ms
);
796 /* Common routine for reading and writing memory. */
799 rw_common (int dowrite
, const struct ps_prochandle
*ph
, gdb_ps_addr_t addr
,
800 gdb_byte
*buf
, int size
)
803 struct cleanup
*old_chain
;
805 old_chain
= save_inferior_ptid ();
807 if (ptid_tid_p (inferior_ptid
) || !target_thread_alive (inferior_ptid
))
809 /* It's either a thread or an LWP that isn't alive. Any live
810 LWP will do so use the first available.
812 NOTE: We don't need to call switch_to_thread; we're just
814 inferior_ptid
= procfs_first_available ();
817 #if defined (__sparcv9)
818 /* For Sparc64 cross Sparc32, make sure the address has not been
819 accidentally sign-extended (or whatever) to beyond 32 bits. */
820 if (bfd_get_arch_size (exec_bfd
) == 32)
825 ret
= target_write_memory (addr
, (gdb_byte
*) buf
, size
);
827 ret
= target_read_memory (addr
, (gdb_byte
*) buf
, size
);
829 do_cleanups (old_chain
);
831 return (ret
== 0 ? PS_OK
: PS_ERR
);
834 /* Copies SIZE bytes from target process .data segment to debugger memory. */
837 ps_pdread (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
838 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
840 return rw_common (0, ph
, addr
, (gdb_byte
*) buf
, size
);
843 /* Copies SIZE bytes from debugger memory .data segment to target process. */
846 ps_pdwrite (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
847 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
849 return rw_common (1, ph
, addr
, (gdb_byte
*) buf
, size
);
852 /* Copies SIZE bytes from target process .text segment to debugger memory. */
855 ps_ptread (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
856 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
858 return rw_common (0, ph
, addr
, (gdb_byte
*) buf
, size
);
861 /* Copies SIZE bytes from debugger memory .text segment to target process. */
864 ps_ptwrite (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
865 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
867 return rw_common (1, ph
, addr
, (gdb_byte
*) buf
, size
);
870 /* Get general-purpose registers for LWP. */
873 ps_lgetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, prgregset_t gregset
)
875 struct cleanup
*old_chain
;
876 struct regcache
*regcache
;
878 old_chain
= save_inferior_ptid ();
880 inferior_ptid
= ptid_build (ptid_get_pid (inferior_ptid
), lwpid
, 0);
881 regcache
= get_thread_arch_regcache (inferior_ptid
, target_gdbarch ());
883 target_fetch_registers (regcache
, -1);
884 fill_gregset (regcache
, (gdb_gregset_t
*) gregset
, -1);
886 do_cleanups (old_chain
);
891 /* Set general-purpose registers for LWP. */
894 ps_lsetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
895 const prgregset_t gregset
)
897 struct cleanup
*old_chain
;
898 struct regcache
*regcache
;
900 old_chain
= save_inferior_ptid ();
902 inferior_ptid
= ptid_build (ptid_get_pid (inferior_ptid
), lwpid
, 0);
903 regcache
= get_thread_arch_regcache (inferior_ptid
, target_gdbarch ());
905 supply_gregset (regcache
, (const gdb_gregset_t
*) gregset
);
906 target_store_registers (regcache
, -1);
908 do_cleanups (old_chain
);
913 /* Log a message (sends to gdb_stderr). */
916 ps_plog (const char *fmt
, ...)
920 va_start (args
, fmt
);
922 vfprintf_filtered (gdb_stderr
, fmt
, args
);
925 /* Get size of extra register set. Currently a noop. */
928 ps_lgetxregsize (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, int *xregsize
)
933 /* Get extra register set. Currently a noop. */
936 ps_lgetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
941 /* Set extra register set. Currently a noop. */
944 ps_lsetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
949 /* Get floating-point registers for LWP. */
952 ps_lgetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
953 prfpregset_t
*fpregset
)
955 struct cleanup
*old_chain
;
956 struct regcache
*regcache
;
958 old_chain
= save_inferior_ptid ();
960 inferior_ptid
= ptid_build (ptid_get_pid (inferior_ptid
), lwpid
, 0);
961 regcache
= get_thread_arch_regcache (inferior_ptid
, target_gdbarch ());
963 target_fetch_registers (regcache
, -1);
964 fill_fpregset (regcache
, (gdb_fpregset_t
*) fpregset
, -1);
966 do_cleanups (old_chain
);
971 /* Set floating-point regs for LWP. */
974 ps_lsetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
975 const prfpregset_t
* fpregset
)
977 struct cleanup
*old_chain
;
978 struct regcache
*regcache
;
980 old_chain
= save_inferior_ptid ();
982 inferior_ptid
= ptid_build (ptid_get_pid (inferior_ptid
), lwpid
, 0);
983 regcache
= get_thread_arch_regcache (inferior_ptid
, target_gdbarch ());
985 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregset
);
986 target_store_registers (regcache
, -1);
988 do_cleanups (old_chain
);
994 /* Identify process as 32-bit or 64-bit. At the moment we're using
995 BFD to do this. There might be a more Solaris-specific
996 (e.g. procfs) method, but this ought to work. */
999 ps_pdmodel (gdb_ps_prochandle_t ph
, int *data_model
)
1002 *data_model
= PR_MODEL_UNKNOWN
;
1003 else if (bfd_get_arch_size (exec_bfd
) == 32)
1004 *data_model
= PR_MODEL_ILP32
;
1006 *data_model
= PR_MODEL_LP64
;
1010 #endif /* PR_MODEL_LP64 */
1012 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
1014 /* Reads the local descriptor table of a LWP.
1016 This function is necessary on x86-solaris only. Without it, the loading
1017 of libthread_db would fail because of ps_lgetLDT being undefined. */
1020 ps_lgetLDT (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1023 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */
1026 /* FIXME: can't I get the process ID from the prochandle or
1029 if (ptid_get_pid (inferior_ptid
) <= 0 || lwpid
<= 0)
1032 ret
= procfs_find_LDT_entry (ptid_build (ptid_get_pid (inferior_ptid
),
1036 memcpy (pldt
, ret
, sizeof (struct ssd
));
1040 /* LDT not found. */
1046 /* Convert PTID to printable form. */
1049 solaris_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1051 static char buf
[100];
1053 if (ptid_tid_p (ptid
))
1057 lwp
= thread_to_lwp (ptid
, -2);
1059 if (ptid_get_pid (lwp
) == -1)
1060 xsnprintf (buf
, sizeof (buf
), "Thread %ld (defunct)",
1061 ptid_get_tid (ptid
));
1062 else if (ptid_get_pid (lwp
) != -2)
1063 xsnprintf (buf
, sizeof (buf
), "Thread %ld (LWP %ld)",
1064 ptid_get_tid (ptid
), ptid_get_lwp (lwp
));
1066 xsnprintf (buf
, sizeof (buf
), "Thread %ld ",
1067 ptid_get_tid (ptid
));
1069 else if (ptid_get_lwp (ptid
) != 0)
1070 xsnprintf (buf
, sizeof (buf
), "LWP %ld ", ptid_get_lwp (ptid
));
1072 xsnprintf (buf
, sizeof (buf
), "process %d ", ptid_get_pid (ptid
));
1078 /* Worker bee for update_thread_list. Callback function that gets
1079 called once per user-level thread (i.e. not for LWP's). */
1082 sol_update_thread_list_callback (const td_thrhandle_t
*th
, void *ignored
)
1088 retval
= p_td_thr_get_info (th
, &ti
);
1089 if (retval
!= TD_OK
)
1092 ptid
= ptid_build (ptid_get_pid (inferior_ptid
), 0, ti
.ti_tid
);
1093 if (!in_thread_list (ptid
) || is_exited (ptid
))
1100 sol_update_thread_list (struct target_ops
*ops
)
1102 struct target_ops
*beneath
= find_target_beneath (ops
);
1104 /* Delete dead threads. */
1107 /* Find any new LWP's. */
1108 beneath
->to_update_thread_list (beneath
);
1110 /* Then find any new user-level threads. */
1111 p_td_ta_thr_iter (main_ta
, sol_update_thread_list_callback
, (void *) 0,
1112 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1113 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1116 /* Worker bee for the "info sol-thread" command. This is a callback
1117 function that gets called once for each Solaris user-level thread
1118 (i.e. not for LWPs) in the inferior. Print anything interesting
1119 that we can think of. */
1122 info_cb (const td_thrhandle_t
*th
, void *s
)
1127 ret
= p_td_thr_get_info (th
, &ti
);
1130 printf_filtered ("%s thread #%d, lwp %d, ",
1131 ti
.ti_type
== TD_THR_SYSTEM
? "system" : "user ",
1132 ti
.ti_tid
, ti
.ti_lid
);
1133 switch (ti
.ti_state
)
1136 case TD_THR_UNKNOWN
:
1137 printf_filtered ("<unknown state>");
1139 case TD_THR_STOPPED
:
1140 printf_filtered ("(stopped)");
1143 printf_filtered ("(run) ");
1146 printf_filtered ("(active) ");
1149 printf_filtered ("(zombie) ");
1152 printf_filtered ("(asleep) ");
1154 case TD_THR_STOPPED_ASLEEP
:
1155 printf_filtered ("(stopped asleep)");
1158 /* Print thr_create start function. */
1159 if (ti
.ti_startfunc
!= 0)
1161 const struct bound_minimal_symbol msym
1162 = lookup_minimal_symbol_by_pc (ti
.ti_startfunc
);
1164 printf_filtered (" startfunc=%s",
1166 ? MSYMBOL_PRINT_NAME (msym
.minsym
)
1167 : paddress (target_gdbarch (), ti
.ti_startfunc
));
1170 /* If thread is asleep, print function that went to sleep. */
1171 if (ti
.ti_state
== TD_THR_SLEEP
)
1173 const struct bound_minimal_symbol msym
1174 = lookup_minimal_symbol_by_pc (ti
.ti_pc
);
1176 printf_filtered (" sleepfunc=%s",
1178 ? MSYMBOL_PRINT_NAME (msym
.minsym
)
1179 : paddress (target_gdbarch (), ti
.ti_pc
));
1182 printf_filtered ("\n");
1185 warning (_("info sol-thread: failed to get info for thread."));
1190 /* List some state about each Solaris user-level thread in the
1194 info_solthreads (char *args
, int from_tty
)
1196 p_td_ta_thr_iter (main_ta
, info_cb
, args
,
1197 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1198 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1201 /* Callback routine used to find a thread based on the TID part of
1205 thread_db_find_thread_from_tid (struct thread_info
*thread
, void *data
)
1207 long *tid
= (long *) data
;
1209 if (ptid_get_tid (thread
->ptid
) == *tid
)
1216 sol_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
1218 struct thread_info
*thread_info
=
1219 iterate_over_threads (thread_db_find_thread_from_tid
, &thread
);
1221 if (thread_info
== NULL
)
1223 /* The list of threads is probably not up to date. Find any
1224 thread that is missing from the list, and try again. */
1225 sol_update_thread_list (¤t_target
);
1226 thread_info
= iterate_over_threads (thread_db_find_thread_from_tid
,
1230 gdb_assert (thread_info
!= NULL
);
1232 return (thread_info
->ptid
);
1236 init_sol_thread_ops (void)
1238 sol_thread_ops
.to_shortname
= "solaris-threads";
1239 sol_thread_ops
.to_longname
= "Solaris threads and pthread.";
1240 sol_thread_ops
.to_doc
= "Solaris threads and pthread support.";
1241 sol_thread_ops
.to_detach
= sol_thread_detach
;
1242 sol_thread_ops
.to_resume
= sol_thread_resume
;
1243 sol_thread_ops
.to_wait
= sol_thread_wait
;
1244 sol_thread_ops
.to_fetch_registers
= sol_thread_fetch_registers
;
1245 sol_thread_ops
.to_store_registers
= sol_thread_store_registers
;
1246 sol_thread_ops
.to_xfer_partial
= sol_thread_xfer_partial
;
1247 sol_thread_ops
.to_mourn_inferior
= sol_thread_mourn_inferior
;
1248 sol_thread_ops
.to_thread_alive
= sol_thread_alive
;
1249 sol_thread_ops
.to_pid_to_str
= solaris_pid_to_str
;
1250 sol_thread_ops
.to_update_thread_list
= sol_update_thread_list
;
1251 sol_thread_ops
.to_stratum
= thread_stratum
;
1252 sol_thread_ops
.to_get_ada_task_ptid
= sol_get_ada_task_ptid
;
1253 sol_thread_ops
.to_magic
= OPS_MAGIC
;
1256 /* Silence -Wmissing-prototypes. */
1257 extern void _initialize_sol_thread (void);
1260 _initialize_sol_thread (void)
1264 init_sol_thread_ops ();
1266 dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
);
1270 #define resolve(X) \
1271 if (!(p_##X = (X ## _ftype *) dlsym (dlhandle, #X))) \
1275 resolve (td_ta_new
);
1276 resolve (td_ta_delete
);
1278 resolve (td_ta_get_ph
);
1279 resolve (td_ta_get_nthreads
);
1280 resolve (td_ta_tsd_iter
);
1281 resolve (td_ta_thr_iter
);
1282 resolve (td_thr_validate
);
1283 resolve (td_thr_tsd
);
1284 resolve (td_thr_get_info
);
1285 resolve (td_thr_getfpregs
);
1286 resolve (td_thr_getxregsize
);
1287 resolve (td_thr_getxregs
);
1288 resolve (td_thr_sigsetmask
);
1289 resolve (td_thr_setprio
);
1290 resolve (td_thr_setsigpending
);
1291 resolve (td_thr_setfpregs
);
1292 resolve (td_thr_setxregs
);
1293 resolve (td_ta_map_id2thr
);
1294 resolve (td_ta_map_lwp2thr
);
1295 resolve (td_thr_getgregs
);
1296 resolve (td_thr_setgregs
);
1298 complete_target_initialization (&sol_thread_ops
);
1300 add_cmd ("sol-threads", class_maintenance
, info_solthreads
,
1301 _("Show info on Solaris user threads."), &maintenanceinfolist
);
1303 /* Hook into new_objfile notification. */
1304 observer_attach_new_objfile (sol_thread_new_objfile
);
1308 fprintf_unfiltered (gdb_stderr
, "\
1309 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ());