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 target_ops
*beneath
= find_target_beneath (ops
);
372 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
374 inferior_ptid
= thread_to_lwp (inferior_ptid
, ptid_get_pid (main_ph
.ptid
));
375 if (ptid_get_pid (inferior_ptid
) == -1)
376 inferior_ptid
= procfs_first_available ();
378 if (ptid_get_pid (ptid
) != -1)
380 ptid_t save_ptid
= ptid
;
382 ptid
= thread_to_lwp (ptid
, -2);
383 if (ptid_get_pid (ptid
) == -2) /* Inactive thread. */
384 error (_("This version of Solaris can't start inactive threads."));
385 if (info_verbose
&& ptid_get_pid (ptid
) == -1)
386 warning (_("Specified thread %ld seems to have terminated"),
387 ptid_get_tid (save_ptid
));
390 beneath
->to_resume (beneath
, ptid
, step
, signo
);
393 /* Wait for any threads to stop. We may have to convert PTID from a
394 thread ID to an LWP ID, and vice versa on the way out. */
397 sol_thread_wait (struct target_ops
*ops
,
398 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
402 struct target_ops
*beneath
= find_target_beneath (ops
);
404 save_ptid
= inferior_ptid
;
405 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
407 inferior_ptid
= thread_to_lwp (inferior_ptid
, ptid_get_pid (main_ph
.ptid
));
408 if (ptid_get_pid (inferior_ptid
) == -1)
409 inferior_ptid
= procfs_first_available ();
411 if (ptid_get_pid (ptid
) != -1)
413 ptid_t save_ptid
= ptid
;
415 ptid
= thread_to_lwp (ptid
, -2);
416 if (ptid_get_pid (ptid
) == -2) /* Inactive thread. */
417 error (_("This version of Solaris can't start inactive threads."));
418 if (info_verbose
&& ptid_get_pid (ptid
) == -1)
419 warning (_("Specified thread %ld seems to have terminated"),
420 ptid_get_tid (save_ptid
));
423 rtnval
= beneath
->to_wait (beneath
, ptid
, ourstatus
, options
);
425 if (ourstatus
->kind
!= TARGET_WAITKIND_EXITED
)
427 /* Map the LWP of interest back to the appropriate thread ID. */
428 rtnval
= lwp_to_thread (rtnval
);
429 if (ptid_get_pid (rtnval
) == -1)
432 /* See if we have a new thread. */
433 if (ptid_tid_p (rtnval
)
434 && !ptid_equal (rtnval
, save_ptid
)
435 && (!in_thread_list (rtnval
)
436 || is_exited (rtnval
)))
440 /* During process initialization, we may get here without the thread
441 package being initialized, since that can only happen after we've
442 found the shared libs. */
448 sol_thread_fetch_registers (struct target_ops
*ops
,
449 struct regcache
*regcache
, int regnum
)
452 td_thrhandle_t thandle
;
455 prfpregset_t fpregset
;
456 gdb_gregset_t
*gregset_p
= &gregset
;
457 gdb_fpregset_t
*fpregset_p
= &fpregset
;
458 struct target_ops
*beneath
= find_target_beneath (ops
);
459 ptid_t ptid
= regcache_get_ptid (regcache
);
461 if (!ptid_tid_p (ptid
))
463 /* It's an LWP; pass the request on to the layer beneath. */
464 beneath
->to_fetch_registers (beneath
, regcache
, regnum
);
468 /* Solaris thread: convert PTID into a td_thrhandle_t. */
469 thread
= ptid_get_tid (ptid
);
471 error (_("sol_thread_fetch_registers: thread == 0"));
473 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
475 error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"),
476 td_err_string (val
));
478 /* Get the general-purpose registers. */
480 val
= p_td_thr_getgregs (&thandle
, gregset
);
481 if (val
!= TD_OK
&& val
!= TD_PARTIALREG
)
482 error (_("sol_thread_fetch_registers: td_thr_getgregs %s"),
483 td_err_string (val
));
485 /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
486 and %sp are saved (by a thread context switch). */
488 /* And, now the floating-point registers. */
490 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
491 if (val
!= TD_OK
&& val
!= TD_NOFPREGS
)
492 error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"),
493 td_err_string (val
));
495 /* Note that we must call supply_gregset and supply_fpregset *after*
496 calling the td routines because the td routines call ps_lget*
497 which affect the values stored in the registers array. */
499 supply_gregset (regcache
, (const gdb_gregset_t
*) gregset_p
);
500 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregset_p
);
504 sol_thread_store_registers (struct target_ops
*ops
,
505 struct regcache
*regcache
, int regnum
)
508 td_thrhandle_t thandle
;
511 prfpregset_t fpregset
;
512 ptid_t ptid
= regcache_get_ptid (regcache
);
514 if (!ptid_tid_p (ptid
))
516 struct target_ops
*beneath
= find_target_beneath (ops
);
518 /* It's an LWP; pass the request on to the layer beneath. */
519 beneath
->to_store_registers (beneath
, regcache
, regnum
);
523 /* Solaris thread: convert PTID into a td_thrhandle_t. */
524 thread
= ptid_get_tid (ptid
);
526 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
528 error (_("sol_thread_store_registers: td_ta_map_id2thr %s"),
529 td_err_string (val
));
533 val
= p_td_thr_getgregs (&thandle
, gregset
);
535 error (_("sol_thread_store_registers: td_thr_getgregs %s"),
536 td_err_string (val
));
537 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
539 error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
540 td_err_string (val
));
543 fill_gregset (regcache
, (gdb_gregset_t
*) &gregset
, regnum
);
544 fill_fpregset (regcache
, (gdb_fpregset_t
*) &fpregset
, regnum
);
546 val
= p_td_thr_setgregs (&thandle
, gregset
);
548 error (_("sol_thread_store_registers: td_thr_setgregs %s"),
549 td_err_string (val
));
550 val
= p_td_thr_setfpregs (&thandle
, &fpregset
);
552 error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
553 td_err_string (val
));
556 /* Perform partial transfers on OBJECT. See target_read_partial and
557 target_write_partial for details of each variant. One, and only
558 one, of readbuf or writebuf must be non-NULL. */
560 static enum target_xfer_status
561 sol_thread_xfer_partial (struct target_ops
*ops
, enum target_object object
,
562 const char *annex
, gdb_byte
*readbuf
,
563 const gdb_byte
*writebuf
,
564 ULONGEST offset
, ULONGEST len
, ULONGEST
*xfered_len
)
566 struct target_ops
*beneath
= find_target_beneath (ops
);
568 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
570 if (ptid_tid_p (inferior_ptid
) || !target_thread_alive (inferior_ptid
))
572 /* It's either a thread or an LWP that isn't alive. Any live
573 LWP will do so use the first available.
575 NOTE: We don't need to call switch_to_thread; we're just
577 inferior_ptid
= procfs_first_available ();
580 return beneath
->to_xfer_partial (beneath
, object
, annex
, readbuf
,
581 writebuf
, offset
, len
, xfered_len
);
585 check_for_thread_db (void)
590 /* Don't attempt to use thread_db for remote targets. */
591 if (!(target_can_run (¤t_target
) || core_bfd
))
594 /* Do nothing if we couldn't load libthread_db.so.1. */
595 if (p_td_ta_new
== NULL
)
598 if (sol_thread_active
)
599 /* Nothing to do. The thread library was already detected and the
600 target vector was already activated. */
603 /* Now, initialize libthread_db. This needs to be done after the
604 shared libraries are located because it needs information from
605 the user's thread library. */
610 warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (err
));
614 /* Now attempt to open a connection to the thread library. */
615 err
= p_td_ta_new (&main_ph
, &main_ta
);
619 /* No thread library was detected. */
623 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
625 /* The thread library was detected. Activate the sol_thread target. */
626 push_target (&sol_thread_ops
);
627 sol_thread_active
= 1;
629 main_ph
.ptid
= inferior_ptid
; /* Save for xfer_memory. */
630 ptid
= lwp_to_thread (inferior_ptid
);
631 if (ptid_get_pid (ptid
) != -1)
632 inferior_ptid
= ptid
;
634 target_update_thread_list ();
638 warning (_("Cannot initialize thread debugging library: %s"),
639 td_err_string (err
));
644 /* This routine is called whenever a new symbol table is read in, or
645 when all symbol tables are removed. libthread_db can only be
646 initialized when it finds the right variables in libthread.so.
647 Since it's a shared library, those variables don't show up until
648 the library gets mapped and the symbol table is read in. */
651 sol_thread_new_objfile (struct objfile
*objfile
)
654 check_for_thread_db ();
657 /* Clean up after the inferior dies. */
660 sol_thread_mourn_inferior (struct target_ops
*ops
)
662 struct target_ops
*beneath
= find_target_beneath (ops
);
664 sol_thread_active
= 0;
668 beneath
->to_mourn_inferior (beneath
);
671 /* Return true if PTID is still active in the inferior. */
674 sol_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
676 if (ptid_tid_p (ptid
))
678 /* It's a (user-level) thread. */
683 pid
= ptid_get_tid (ptid
);
684 if ((val
= p_td_ta_map_id2thr (main_ta
, pid
, &th
)) != TD_OK
)
685 return 0; /* Thread not found. */
686 if ((val
= p_td_thr_validate (&th
)) != TD_OK
)
687 return 0; /* Thread not valid. */
688 return 1; /* Known thread. */
692 struct target_ops
*beneath
= find_target_beneath (ops
);
694 /* It's an LPW; pass the request on to the layer below. */
695 return beneath
->to_thread_alive (beneath
, ptid
);
700 /* These routines implement the lower half of the thread_db interface,
701 i.e. the ps_* routines. */
703 /* Various versions of <proc_service.h> have slightly different
704 function prototypes. In particular, we have
707 struct ps_prochandle * const struct ps_prochandle *
712 Which one you have depends on the Solaris version and what patches
713 you've applied. On the theory that there are only two major
714 variants, we have configure check the prototype of ps_pdwrite (),
715 and use that info to make appropriate typedefs here. */
717 #ifdef PROC_SERVICE_IS_OLD
718 typedef const struct ps_prochandle
*gdb_ps_prochandle_t
;
719 typedef char *gdb_ps_read_buf_t
;
720 typedef char *gdb_ps_write_buf_t
;
721 typedef int gdb_ps_size_t
;
722 typedef psaddr_t gdb_ps_addr_t
;
724 typedef struct ps_prochandle
*gdb_ps_prochandle_t
;
725 typedef void *gdb_ps_read_buf_t
;
726 typedef const void *gdb_ps_write_buf_t
;
727 typedef size_t gdb_ps_size_t
;
728 typedef psaddr_t gdb_ps_addr_t
;
731 /* The next four routines are called by libthread_db to tell us to
732 stop and stop a particular process or lwp. Since GDB ensures that
733 these are all stopped by the time we call anything in thread_db,
734 these routines need to do nothing. */
739 ps_pstop (gdb_ps_prochandle_t ph
)
744 /* Process continue. */
747 ps_pcontinue (gdb_ps_prochandle_t ph
)
755 ps_lstop (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
763 ps_lcontinue (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
768 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
771 ps_pglobal_lookup (gdb_ps_prochandle_t ph
, const char *ld_object_name
,
772 const char *ld_symbol_name
, gdb_ps_addr_t
*ld_symbol_addr
)
774 struct bound_minimal_symbol ms
;
776 ms
= lookup_minimal_symbol (ld_symbol_name
, NULL
, NULL
);
780 *ld_symbol_addr
= BMSYMBOL_VALUE_ADDRESS (ms
);
784 /* Common routine for reading and writing memory. */
787 rw_common (int dowrite
, const struct ps_prochandle
*ph
, gdb_ps_addr_t addr
,
788 gdb_byte
*buf
, int size
)
792 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
794 if (ptid_tid_p (inferior_ptid
) || !target_thread_alive (inferior_ptid
))
796 /* It's either a thread or an LWP that isn't alive. Any live
797 LWP will do so use the first available.
799 NOTE: We don't need to call switch_to_thread; we're just
801 inferior_ptid
= procfs_first_available ();
804 #if defined (__sparcv9)
805 /* For Sparc64 cross Sparc32, make sure the address has not been
806 accidentally sign-extended (or whatever) to beyond 32 bits. */
807 if (bfd_get_arch_size (exec_bfd
) == 32)
812 ret
= target_write_memory (addr
, (gdb_byte
*) buf
, size
);
814 ret
= target_read_memory (addr
, (gdb_byte
*) buf
, size
);
816 return (ret
== 0 ? PS_OK
: PS_ERR
);
819 /* Copies SIZE bytes from target process .data segment to debugger memory. */
822 ps_pdread (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
823 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
825 return rw_common (0, ph
, addr
, (gdb_byte
*) buf
, size
);
828 /* Copies SIZE bytes from debugger memory .data segment to target process. */
831 ps_pdwrite (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
832 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
834 return rw_common (1, ph
, addr
, (gdb_byte
*) buf
, size
);
837 /* Copies SIZE bytes from target process .text segment to debugger memory. */
840 ps_ptread (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
841 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
843 return rw_common (0, ph
, addr
, (gdb_byte
*) buf
, size
);
846 /* Copies SIZE bytes from debugger memory .text segment to target process. */
849 ps_ptwrite (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
850 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
852 return rw_common (1, ph
, addr
, (gdb_byte
*) buf
, size
);
855 /* Get general-purpose registers for LWP. */
858 ps_lgetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, prgregset_t gregset
)
860 ptid_t ptid
= ptid_build (ptid_get_pid (inferior_ptid
), lwpid
, 0);
861 struct regcache
*regcache
862 = get_thread_arch_regcache (ptid
, target_gdbarch ());
864 target_fetch_registers (regcache
, -1);
865 fill_gregset (regcache
, (gdb_gregset_t
*) gregset
, -1);
870 /* Set general-purpose registers for LWP. */
873 ps_lsetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
874 const prgregset_t gregset
)
876 ptid_t ptid
= ptid_build (ptid_get_pid (inferior_ptid
), lwpid
, 0);
877 struct regcache
*regcache
878 = get_thread_arch_regcache (ptid
, target_gdbarch ());
880 supply_gregset (regcache
, (const gdb_gregset_t
*) gregset
);
881 target_store_registers (regcache
, -1);
886 /* Log a message (sends to gdb_stderr). */
889 ps_plog (const char *fmt
, ...)
893 va_start (args
, fmt
);
895 vfprintf_filtered (gdb_stderr
, fmt
, args
);
898 /* Get size of extra register set. Currently a noop. */
901 ps_lgetxregsize (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, int *xregsize
)
906 /* Get extra register set. Currently a noop. */
909 ps_lgetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
914 /* Set extra register set. Currently a noop. */
917 ps_lsetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
922 /* Get floating-point registers for LWP. */
925 ps_lgetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
926 prfpregset_t
*fpregset
)
928 ptid_t ptid
= ptid_build (ptid_get_pid (inferior_ptid
), lwpid
, 0);
929 struct regcache
*regcache
930 = get_thread_arch_regcache (ptid
, target_gdbarch ());
932 target_fetch_registers (regcache
, -1);
933 fill_fpregset (regcache
, (gdb_fpregset_t
*) fpregset
, -1);
938 /* Set floating-point regs for LWP. */
941 ps_lsetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
942 const prfpregset_t
* fpregset
)
944 ptid_t ptid
= ptid_build (ptid_get_pid (inferior_ptid
), lwpid
, 0);
945 struct regcache
*regcache
946 = get_thread_arch_regcache (ptid
, target_gdbarch ());
948 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregset
);
949 target_store_registers (regcache
, -1);
955 /* Identify process as 32-bit or 64-bit. At the moment we're using
956 BFD to do this. There might be a more Solaris-specific
957 (e.g. procfs) method, but this ought to work. */
960 ps_pdmodel (gdb_ps_prochandle_t ph
, int *data_model
)
963 *data_model
= PR_MODEL_UNKNOWN
;
964 else if (bfd_get_arch_size (exec_bfd
) == 32)
965 *data_model
= PR_MODEL_ILP32
;
967 *data_model
= PR_MODEL_LP64
;
971 #endif /* PR_MODEL_LP64 */
973 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
975 /* Reads the local descriptor table of a LWP.
977 This function is necessary on x86-solaris only. Without it, the loading
978 of libthread_db would fail because of ps_lgetLDT being undefined. */
981 ps_lgetLDT (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
984 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */
987 /* FIXME: can't I get the process ID from the prochandle or
990 if (ptid_get_pid (inferior_ptid
) <= 0 || lwpid
<= 0)
993 ret
= procfs_find_LDT_entry (ptid_build (ptid_get_pid (inferior_ptid
),
997 memcpy (pldt
, ret
, sizeof (struct ssd
));
1001 /* LDT not found. */
1007 /* Convert PTID to printable form. */
1010 solaris_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1012 static char buf
[100];
1014 if (ptid_tid_p (ptid
))
1018 lwp
= thread_to_lwp (ptid
, -2);
1020 if (ptid_get_pid (lwp
) == -1)
1021 xsnprintf (buf
, sizeof (buf
), "Thread %ld (defunct)",
1022 ptid_get_tid (ptid
));
1023 else if (ptid_get_pid (lwp
) != -2)
1024 xsnprintf (buf
, sizeof (buf
), "Thread %ld (LWP %ld)",
1025 ptid_get_tid (ptid
), ptid_get_lwp (lwp
));
1027 xsnprintf (buf
, sizeof (buf
), "Thread %ld ",
1028 ptid_get_tid (ptid
));
1030 else if (ptid_get_lwp (ptid
) != 0)
1031 xsnprintf (buf
, sizeof (buf
), "LWP %ld ", ptid_get_lwp (ptid
));
1033 xsnprintf (buf
, sizeof (buf
), "process %d ", ptid_get_pid (ptid
));
1039 /* Worker bee for update_thread_list. Callback function that gets
1040 called once per user-level thread (i.e. not for LWP's). */
1043 sol_update_thread_list_callback (const td_thrhandle_t
*th
, void *ignored
)
1049 retval
= p_td_thr_get_info (th
, &ti
);
1050 if (retval
!= TD_OK
)
1053 ptid
= ptid_build (ptid_get_pid (inferior_ptid
), 0, ti
.ti_tid
);
1054 if (!in_thread_list (ptid
) || is_exited (ptid
))
1061 sol_update_thread_list (struct target_ops
*ops
)
1063 struct target_ops
*beneath
= find_target_beneath (ops
);
1065 /* Delete dead threads. */
1068 /* Find any new LWP's. */
1069 beneath
->to_update_thread_list (beneath
);
1071 /* Then find any new user-level threads. */
1072 p_td_ta_thr_iter (main_ta
, sol_update_thread_list_callback
, (void *) 0,
1073 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1074 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1077 /* Worker bee for the "info sol-thread" command. This is a callback
1078 function that gets called once for each Solaris user-level thread
1079 (i.e. not for LWPs) in the inferior. Print anything interesting
1080 that we can think of. */
1083 info_cb (const td_thrhandle_t
*th
, void *s
)
1088 ret
= p_td_thr_get_info (th
, &ti
);
1091 printf_filtered ("%s thread #%d, lwp %d, ",
1092 ti
.ti_type
== TD_THR_SYSTEM
? "system" : "user ",
1093 ti
.ti_tid
, ti
.ti_lid
);
1094 switch (ti
.ti_state
)
1097 case TD_THR_UNKNOWN
:
1098 printf_filtered ("<unknown state>");
1100 case TD_THR_STOPPED
:
1101 printf_filtered ("(stopped)");
1104 printf_filtered ("(run) ");
1107 printf_filtered ("(active) ");
1110 printf_filtered ("(zombie) ");
1113 printf_filtered ("(asleep) ");
1115 case TD_THR_STOPPED_ASLEEP
:
1116 printf_filtered ("(stopped asleep)");
1119 /* Print thr_create start function. */
1120 if (ti
.ti_startfunc
!= 0)
1122 const struct bound_minimal_symbol msym
1123 = lookup_minimal_symbol_by_pc (ti
.ti_startfunc
);
1125 printf_filtered (" startfunc=%s",
1127 ? MSYMBOL_PRINT_NAME (msym
.minsym
)
1128 : paddress (target_gdbarch (), ti
.ti_startfunc
));
1131 /* If thread is asleep, print function that went to sleep. */
1132 if (ti
.ti_state
== TD_THR_SLEEP
)
1134 const struct bound_minimal_symbol msym
1135 = lookup_minimal_symbol_by_pc (ti
.ti_pc
);
1137 printf_filtered (" sleepfunc=%s",
1139 ? MSYMBOL_PRINT_NAME (msym
.minsym
)
1140 : paddress (target_gdbarch (), ti
.ti_pc
));
1143 printf_filtered ("\n");
1146 warning (_("info sol-thread: failed to get info for thread."));
1151 /* List some state about each Solaris user-level thread in the
1155 info_solthreads (char *args
, int from_tty
)
1157 p_td_ta_thr_iter (main_ta
, info_cb
, args
,
1158 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1159 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1162 /* Callback routine used to find a thread based on the TID part of
1166 thread_db_find_thread_from_tid (struct thread_info
*thread
, void *data
)
1168 long *tid
= (long *) data
;
1170 if (ptid_get_tid (thread
->ptid
) == *tid
)
1177 sol_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
1179 struct thread_info
*thread_info
=
1180 iterate_over_threads (thread_db_find_thread_from_tid
, &thread
);
1182 if (thread_info
== NULL
)
1184 /* The list of threads is probably not up to date. Find any
1185 thread that is missing from the list, and try again. */
1186 sol_update_thread_list (¤t_target
);
1187 thread_info
= iterate_over_threads (thread_db_find_thread_from_tid
,
1191 gdb_assert (thread_info
!= NULL
);
1193 return (thread_info
->ptid
);
1197 init_sol_thread_ops (void)
1199 sol_thread_ops
.to_shortname
= "solaris-threads";
1200 sol_thread_ops
.to_longname
= "Solaris threads and pthread.";
1201 sol_thread_ops
.to_doc
= "Solaris threads and pthread support.";
1202 sol_thread_ops
.to_detach
= sol_thread_detach
;
1203 sol_thread_ops
.to_resume
= sol_thread_resume
;
1204 sol_thread_ops
.to_wait
= sol_thread_wait
;
1205 sol_thread_ops
.to_fetch_registers
= sol_thread_fetch_registers
;
1206 sol_thread_ops
.to_store_registers
= sol_thread_store_registers
;
1207 sol_thread_ops
.to_xfer_partial
= sol_thread_xfer_partial
;
1208 sol_thread_ops
.to_mourn_inferior
= sol_thread_mourn_inferior
;
1209 sol_thread_ops
.to_thread_alive
= sol_thread_alive
;
1210 sol_thread_ops
.to_pid_to_str
= solaris_pid_to_str
;
1211 sol_thread_ops
.to_update_thread_list
= sol_update_thread_list
;
1212 sol_thread_ops
.to_stratum
= thread_stratum
;
1213 sol_thread_ops
.to_get_ada_task_ptid
= sol_get_ada_task_ptid
;
1214 sol_thread_ops
.to_magic
= OPS_MAGIC
;
1217 /* Silence -Wmissing-prototypes. */
1218 extern void _initialize_sol_thread (void);
1221 _initialize_sol_thread (void)
1225 init_sol_thread_ops ();
1227 dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
);
1231 #define resolve(X) \
1232 if (!(p_##X = (X ## _ftype *) dlsym (dlhandle, #X))) \
1236 resolve (td_ta_new
);
1237 resolve (td_ta_delete
);
1239 resolve (td_ta_get_ph
);
1240 resolve (td_ta_get_nthreads
);
1241 resolve (td_ta_tsd_iter
);
1242 resolve (td_ta_thr_iter
);
1243 resolve (td_thr_validate
);
1244 resolve (td_thr_tsd
);
1245 resolve (td_thr_get_info
);
1246 resolve (td_thr_getfpregs
);
1247 resolve (td_thr_getxregsize
);
1248 resolve (td_thr_getxregs
);
1249 resolve (td_thr_sigsetmask
);
1250 resolve (td_thr_setprio
);
1251 resolve (td_thr_setsigpending
);
1252 resolve (td_thr_setfpregs
);
1253 resolve (td_thr_setxregs
);
1254 resolve (td_ta_map_id2thr
);
1255 resolve (td_ta_map_lwp2thr
);
1256 resolve (td_thr_getgregs
);
1257 resolve (td_thr_setgregs
);
1259 complete_target_initialization (&sol_thread_ops
);
1261 add_cmd ("sol-threads", class_maintenance
, info_solthreads
,
1262 _("Show info on Solaris user threads."), &maintenanceinfolist
);
1264 /* Hook into new_objfile notification. */
1265 observer_attach_new_objfile (sol_thread_new_objfile
);
1269 fprintf_unfiltered (gdb_stderr
, "\
1270 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ());