1 /* Solaris threads debugging interface.
3 Copyright (C) 1996-2018 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
, inferior
*inf
, 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
, inf
, 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 /* The next four routines are called by libthread_db to tell us to
704 stop and stop a particular process or lwp. Since GDB ensures that
705 these are all stopped by the time we call anything in thread_db,
706 these routines need to do nothing. */
711 ps_pstop (struct ps_prochandle
*ph
)
716 /* Process continue. */
719 ps_pcontinue (struct ps_prochandle
*ph
)
727 ps_lstop (struct ps_prochandle
*ph
, lwpid_t lwpid
)
735 ps_lcontinue (struct ps_prochandle
*ph
, lwpid_t lwpid
)
740 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
743 ps_pglobal_lookup (struct ps_prochandle
*ph
, const char *ld_object_name
,
744 const char *ld_symbol_name
, psaddr_t
*ld_symbol_addr
)
746 struct bound_minimal_symbol ms
;
748 ms
= lookup_minimal_symbol (ld_symbol_name
, NULL
, NULL
);
752 *ld_symbol_addr
= BMSYMBOL_VALUE_ADDRESS (ms
);
756 /* Common routine for reading and writing memory. */
759 rw_common (int dowrite
, const struct ps_prochandle
*ph
, psaddr_t addr
,
760 gdb_byte
*buf
, int size
)
764 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
766 if (ptid_tid_p (inferior_ptid
) || !target_thread_alive (inferior_ptid
))
768 /* It's either a thread or an LWP that isn't alive. Any live
769 LWP will do so use the first available.
771 NOTE: We don't need to call switch_to_thread; we're just
773 inferior_ptid
= procfs_first_available ();
776 #if defined (__sparcv9)
777 /* For Sparc64 cross Sparc32, make sure the address has not been
778 accidentally sign-extended (or whatever) to beyond 32 bits. */
779 if (bfd_get_arch_size (exec_bfd
) == 32)
784 ret
= target_write_memory (addr
, (gdb_byte
*) buf
, size
);
786 ret
= target_read_memory (addr
, (gdb_byte
*) buf
, size
);
788 return (ret
== 0 ? PS_OK
: PS_ERR
);
791 /* Copies SIZE bytes from target process .data segment to debugger memory. */
794 ps_pdread (struct ps_prochandle
*ph
, psaddr_t addr
, void *buf
, size_t size
)
796 return rw_common (0, ph
, addr
, (gdb_byte
*) buf
, size
);
799 /* Copies SIZE bytes from debugger memory .data segment to target process. */
802 ps_pdwrite (struct ps_prochandle
*ph
, psaddr_t addr
,
803 const void *buf
, size_t size
)
805 return rw_common (1, ph
, addr
, (gdb_byte
*) buf
, size
);
808 /* Copies SIZE bytes from target process .text segment to debugger memory. */
811 ps_ptread (struct ps_prochandle
*ph
, psaddr_t addr
, void *buf
, size_t size
)
813 return rw_common (0, ph
, addr
, (gdb_byte
*) buf
, size
);
816 /* Copies SIZE bytes from debugger memory .text segment to target process. */
819 ps_ptwrite (struct ps_prochandle
*ph
, psaddr_t addr
,
820 const void *buf
, size_t size
)
822 return rw_common (1, ph
, addr
, (gdb_byte
*) buf
, size
);
825 /* Get general-purpose registers for LWP. */
828 ps_lgetregs (struct ps_prochandle
*ph
, lwpid_t lwpid
, prgregset_t gregset
)
830 ptid_t ptid
= ptid_build (ptid_get_pid (inferior_ptid
), lwpid
, 0);
831 struct regcache
*regcache
832 = get_thread_arch_regcache (ptid
, target_gdbarch ());
834 target_fetch_registers (regcache
, -1);
835 fill_gregset (regcache
, (gdb_gregset_t
*) gregset
, -1);
840 /* Set general-purpose registers for LWP. */
843 ps_lsetregs (struct ps_prochandle
*ph
, lwpid_t lwpid
,
844 const prgregset_t gregset
)
846 ptid_t ptid
= ptid_build (ptid_get_pid (inferior_ptid
), lwpid
, 0);
847 struct regcache
*regcache
848 = get_thread_arch_regcache (ptid
, target_gdbarch ());
850 supply_gregset (regcache
, (const gdb_gregset_t
*) gregset
);
851 target_store_registers (regcache
, -1);
856 /* Log a message (sends to gdb_stderr). */
859 ps_plog (const char *fmt
, ...)
863 va_start (args
, fmt
);
865 vfprintf_filtered (gdb_stderr
, fmt
, args
);
868 /* Get size of extra register set. Currently a noop. */
871 ps_lgetxregsize (struct ps_prochandle
*ph
, lwpid_t lwpid
, int *xregsize
)
876 /* Get extra register set. Currently a noop. */
879 ps_lgetxregs (struct ps_prochandle
*ph
, lwpid_t lwpid
, caddr_t xregset
)
884 /* Set extra register set. Currently a noop. */
887 ps_lsetxregs (struct ps_prochandle
*ph
, lwpid_t lwpid
, caddr_t xregset
)
892 /* Get floating-point registers for LWP. */
895 ps_lgetfpregs (struct ps_prochandle
*ph
, lwpid_t lwpid
,
896 prfpregset_t
*fpregset
)
898 ptid_t ptid
= ptid_build (ptid_get_pid (inferior_ptid
), lwpid
, 0);
899 struct regcache
*regcache
900 = get_thread_arch_regcache (ptid
, target_gdbarch ());
902 target_fetch_registers (regcache
, -1);
903 fill_fpregset (regcache
, (gdb_fpregset_t
*) fpregset
, -1);
908 /* Set floating-point regs for LWP. */
911 ps_lsetfpregs (struct ps_prochandle
*ph
, lwpid_t lwpid
,
912 const prfpregset_t
* fpregset
)
914 ptid_t ptid
= ptid_build (ptid_get_pid (inferior_ptid
), lwpid
, 0);
915 struct regcache
*regcache
916 = get_thread_arch_regcache (ptid
, target_gdbarch ());
918 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregset
);
919 target_store_registers (regcache
, -1);
925 /* Identify process as 32-bit or 64-bit. At the moment we're using
926 BFD to do this. There might be a more Solaris-specific
927 (e.g. procfs) method, but this ought to work. */
930 ps_pdmodel (struct ps_prochandle
*ph
, int *data_model
)
933 *data_model
= PR_MODEL_UNKNOWN
;
934 else if (bfd_get_arch_size (exec_bfd
) == 32)
935 *data_model
= PR_MODEL_ILP32
;
937 *data_model
= PR_MODEL_LP64
;
941 #endif /* PR_MODEL_LP64 */
943 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
945 /* Reads the local descriptor table of a LWP.
947 This function is necessary on x86-solaris only. Without it, the loading
948 of libthread_db would fail because of ps_lgetLDT being undefined. */
951 ps_lgetLDT (struct ps_prochandle
*ph
, lwpid_t lwpid
,
954 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */
957 /* FIXME: can't I get the process ID from the prochandle or
960 if (ptid_get_pid (inferior_ptid
) <= 0 || lwpid
<= 0)
963 ret
= procfs_find_LDT_entry (ptid_build (ptid_get_pid (inferior_ptid
),
967 memcpy (pldt
, ret
, sizeof (struct ssd
));
977 /* Convert PTID to printable form. */
980 solaris_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
982 static char buf
[100];
984 if (ptid_tid_p (ptid
))
988 lwp
= thread_to_lwp (ptid
, -2);
990 if (ptid_get_pid (lwp
) == -1)
991 xsnprintf (buf
, sizeof (buf
), "Thread %ld (defunct)",
992 ptid_get_tid (ptid
));
993 else if (ptid_get_pid (lwp
) != -2)
994 xsnprintf (buf
, sizeof (buf
), "Thread %ld (LWP %ld)",
995 ptid_get_tid (ptid
), ptid_get_lwp (lwp
));
997 xsnprintf (buf
, sizeof (buf
), "Thread %ld ",
998 ptid_get_tid (ptid
));
1000 else if (ptid_get_lwp (ptid
) != 0)
1001 xsnprintf (buf
, sizeof (buf
), "LWP %ld ", ptid_get_lwp (ptid
));
1003 xsnprintf (buf
, sizeof (buf
), "process %d ", ptid_get_pid (ptid
));
1009 /* Worker bee for update_thread_list. Callback function that gets
1010 called once per user-level thread (i.e. not for LWP's). */
1013 sol_update_thread_list_callback (const td_thrhandle_t
*th
, void *ignored
)
1019 retval
= p_td_thr_get_info (th
, &ti
);
1020 if (retval
!= TD_OK
)
1023 ptid
= ptid_build (ptid_get_pid (inferior_ptid
), 0, ti
.ti_tid
);
1024 if (!in_thread_list (ptid
) || is_exited (ptid
))
1031 sol_update_thread_list (struct target_ops
*ops
)
1033 struct target_ops
*beneath
= find_target_beneath (ops
);
1035 /* Delete dead threads. */
1038 /* Find any new LWP's. */
1039 beneath
->to_update_thread_list (beneath
);
1041 /* Then find any new user-level threads. */
1042 p_td_ta_thr_iter (main_ta
, sol_update_thread_list_callback
, (void *) 0,
1043 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1044 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1047 /* Worker bee for the "info sol-thread" command. This is a callback
1048 function that gets called once for each Solaris user-level thread
1049 (i.e. not for LWPs) in the inferior. Print anything interesting
1050 that we can think of. */
1053 info_cb (const td_thrhandle_t
*th
, void *s
)
1058 ret
= p_td_thr_get_info (th
, &ti
);
1061 printf_filtered ("%s thread #%d, lwp %d, ",
1062 ti
.ti_type
== TD_THR_SYSTEM
? "system" : "user ",
1063 ti
.ti_tid
, ti
.ti_lid
);
1064 switch (ti
.ti_state
)
1067 case TD_THR_UNKNOWN
:
1068 printf_filtered ("<unknown state>");
1070 case TD_THR_STOPPED
:
1071 printf_filtered ("(stopped)");
1074 printf_filtered ("(run) ");
1077 printf_filtered ("(active) ");
1080 printf_filtered ("(zombie) ");
1083 printf_filtered ("(asleep) ");
1085 case TD_THR_STOPPED_ASLEEP
:
1086 printf_filtered ("(stopped asleep)");
1089 /* Print thr_create start function. */
1090 if (ti
.ti_startfunc
!= 0)
1092 const struct bound_minimal_symbol msym
1093 = lookup_minimal_symbol_by_pc (ti
.ti_startfunc
);
1095 printf_filtered (" startfunc=%s",
1097 ? MSYMBOL_PRINT_NAME (msym
.minsym
)
1098 : paddress (target_gdbarch (), ti
.ti_startfunc
));
1101 /* If thread is asleep, print function that went to sleep. */
1102 if (ti
.ti_state
== TD_THR_SLEEP
)
1104 const struct bound_minimal_symbol msym
1105 = lookup_minimal_symbol_by_pc (ti
.ti_pc
);
1107 printf_filtered (" sleepfunc=%s",
1109 ? MSYMBOL_PRINT_NAME (msym
.minsym
)
1110 : paddress (target_gdbarch (), ti
.ti_pc
));
1113 printf_filtered ("\n");
1116 warning (_("info sol-thread: failed to get info for thread."));
1121 /* List some state about each Solaris user-level thread in the
1125 info_solthreads (const char *args
, int from_tty
)
1127 p_td_ta_thr_iter (main_ta
, info_cb
, (void *) args
,
1128 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1129 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1132 /* Callback routine used to find a thread based on the TID part of
1136 thread_db_find_thread_from_tid (struct thread_info
*thread
, void *data
)
1138 long *tid
= (long *) data
;
1140 if (ptid_get_tid (thread
->ptid
) == *tid
)
1147 sol_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
1149 struct thread_info
*thread_info
=
1150 iterate_over_threads (thread_db_find_thread_from_tid
, &thread
);
1152 if (thread_info
== NULL
)
1154 /* The list of threads is probably not up to date. Find any
1155 thread that is missing from the list, and try again. */
1156 sol_update_thread_list (¤t_target
);
1157 thread_info
= iterate_over_threads (thread_db_find_thread_from_tid
,
1161 gdb_assert (thread_info
!= NULL
);
1163 return (thread_info
->ptid
);
1167 init_sol_thread_ops (void)
1169 sol_thread_ops
.to_shortname
= "solaris-threads";
1170 sol_thread_ops
.to_longname
= "Solaris threads and pthread.";
1171 sol_thread_ops
.to_doc
= "Solaris threads and pthread support.";
1172 sol_thread_ops
.to_detach
= sol_thread_detach
;
1173 sol_thread_ops
.to_resume
= sol_thread_resume
;
1174 sol_thread_ops
.to_wait
= sol_thread_wait
;
1175 sol_thread_ops
.to_fetch_registers
= sol_thread_fetch_registers
;
1176 sol_thread_ops
.to_store_registers
= sol_thread_store_registers
;
1177 sol_thread_ops
.to_xfer_partial
= sol_thread_xfer_partial
;
1178 sol_thread_ops
.to_mourn_inferior
= sol_thread_mourn_inferior
;
1179 sol_thread_ops
.to_thread_alive
= sol_thread_alive
;
1180 sol_thread_ops
.to_pid_to_str
= solaris_pid_to_str
;
1181 sol_thread_ops
.to_update_thread_list
= sol_update_thread_list
;
1182 sol_thread_ops
.to_stratum
= thread_stratum
;
1183 sol_thread_ops
.to_get_ada_task_ptid
= sol_get_ada_task_ptid
;
1184 sol_thread_ops
.to_magic
= OPS_MAGIC
;
1188 _initialize_sol_thread (void)
1192 init_sol_thread_ops ();
1194 dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
);
1198 #define resolve(X) \
1199 if (!(p_##X = (X ## _ftype *) dlsym (dlhandle, #X))) \
1203 resolve (td_ta_new
);
1204 resolve (td_ta_delete
);
1206 resolve (td_ta_get_ph
);
1207 resolve (td_ta_get_nthreads
);
1208 resolve (td_ta_tsd_iter
);
1209 resolve (td_ta_thr_iter
);
1210 resolve (td_thr_validate
);
1211 resolve (td_thr_tsd
);
1212 resolve (td_thr_get_info
);
1213 resolve (td_thr_getfpregs
);
1214 resolve (td_thr_getxregsize
);
1215 resolve (td_thr_getxregs
);
1216 resolve (td_thr_sigsetmask
);
1217 resolve (td_thr_setprio
);
1218 resolve (td_thr_setsigpending
);
1219 resolve (td_thr_setfpregs
);
1220 resolve (td_thr_setxregs
);
1221 resolve (td_ta_map_id2thr
);
1222 resolve (td_ta_map_lwp2thr
);
1223 resolve (td_thr_getgregs
);
1224 resolve (td_thr_setgregs
);
1226 complete_target_initialization (&sol_thread_ops
);
1228 add_cmd ("sol-threads", class_maintenance
, info_solthreads
,
1229 _("Show info on Solaris user threads."), &maintenanceinfolist
);
1231 /* Hook into new_objfile notification. */
1232 observer_attach_new_objfile (sol_thread_new_objfile
);
1236 fprintf_unfiltered (gdb_stderr
, "\
1237 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ());