1 /* Solaris threads debugging interface.
3 Copyright (C) 1996-2020 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 respectively) 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"
66 #include "observable.h"
72 static const target_info thread_db_target_info
= {
74 N_("Solaris threads and pthread."),
75 N_("Solaris threads and pthread support.")
78 class sol_thread_target final
: public target_ops
81 const target_info
&info () const override
82 { return thread_db_target_info
; }
84 strata
stratum () const override
{ return thread_stratum
; }
86 void detach (inferior
*, int) override
;
87 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
88 void resume (ptid_t
, int, enum gdb_signal
) override
;
89 void mourn_inferior () override
;
90 std::string
pid_to_str (ptid_t
) override
;
91 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
93 void fetch_registers (struct regcache
*, int) override
;
94 void store_registers (struct regcache
*, int) override
;
96 enum target_xfer_status
xfer_partial (enum target_object object
,
99 const gdb_byte
*writebuf
,
100 ULONGEST offset
, ULONGEST len
,
101 ULONGEST
*xfered_len
) override
;
103 bool thread_alive (ptid_t ptid
) override
;
104 void update_thread_list () override
;
107 static sol_thread_target sol_thread_ops
;
109 /* Prototypes for supply_gregset etc. */
112 /* This struct is defined by us, but mainly used for the proc_service
113 interface. We don't have much use for it, except as a handy place
114 to get a real PID for memory accesses. */
127 static struct ps_prochandle main_ph
;
128 static td_thragent_t
*main_ta
;
129 static int sol_thread_active
= 0;
131 /* Default definitions: These must be defined in tm.h if they are to
132 be shared with a process module such as procfs. */
134 /* Types of the libthread_db functions. */
136 typedef void (td_log_ftype
)(const int on_off
);
137 typedef td_err_e (td_ta_new_ftype
)(const struct ps_prochandle
*ph_p
,
138 td_thragent_t
**ta_pp
);
139 typedef td_err_e (td_ta_delete_ftype
)(td_thragent_t
*ta_p
);
140 typedef td_err_e (td_init_ftype
)(void);
141 typedef td_err_e (td_ta_get_ph_ftype
)(const td_thragent_t
*ta_p
,
142 struct ps_prochandle
**ph_pp
);
143 typedef td_err_e (td_ta_get_nthreads_ftype
)(const td_thragent_t
*ta_p
,
145 typedef td_err_e (td_ta_tsd_iter_ftype
)(const td_thragent_t
*ta_p
,
146 td_key_iter_f
*cb
, void *cbdata_p
);
147 typedef td_err_e (td_ta_thr_iter_ftype
)(const td_thragent_t
*ta_p
,
148 td_thr_iter_f
*cb
, void *cbdata_p
,
149 td_thr_state_e state
, int ti_pri
,
150 sigset_t
*ti_sigmask_p
,
151 unsigned ti_user_flags
);
152 typedef td_err_e (td_thr_validate_ftype
)(const td_thrhandle_t
*th_p
);
153 typedef td_err_e (td_thr_tsd_ftype
)(const td_thrhandle_t
* th_p
,
154 const thread_key_t key
, void **data_pp
);
155 typedef td_err_e (td_thr_get_info_ftype
)(const td_thrhandle_t
*th_p
,
157 typedef td_err_e (td_thr_getfpregs_ftype
)(const td_thrhandle_t
*th_p
,
158 prfpregset_t
*fpregset
);
159 typedef td_err_e (td_thr_getxregsize_ftype
)(const td_thrhandle_t
*th_p
,
161 typedef td_err_e (td_thr_getxregs_ftype
)(const td_thrhandle_t
*th_p
,
162 const caddr_t xregset
);
163 typedef td_err_e (td_thr_sigsetmask_ftype
)(const td_thrhandle_t
*th_p
,
164 const sigset_t ti_sigmask
);
165 typedef td_err_e (td_thr_setprio_ftype
)(const td_thrhandle_t
*th_p
,
167 typedef td_err_e (td_thr_setsigpending_ftype
)(const td_thrhandle_t
*th_p
,
168 const uchar_t ti_pending_flag
,
169 const sigset_t ti_pending
);
170 typedef td_err_e (td_thr_setfpregs_ftype
)(const td_thrhandle_t
*th_p
,
171 const prfpregset_t
*fpregset
);
172 typedef td_err_e (td_thr_setxregs_ftype
)(const td_thrhandle_t
*th_p
,
173 const caddr_t xregset
);
174 typedef td_err_e (td_ta_map_id2thr_ftype
)(const td_thragent_t
*ta_p
,
176 td_thrhandle_t
*th_p
);
177 typedef td_err_e (td_ta_map_lwp2thr_ftype
)(const td_thragent_t
*ta_p
,
179 td_thrhandle_t
*th_p
);
180 typedef td_err_e (td_thr_getgregs_ftype
)(const td_thrhandle_t
*th_p
,
182 typedef td_err_e (td_thr_setgregs_ftype
)(const td_thrhandle_t
*th_p
,
183 const prgregset_t regset
);
185 /* Pointers to routines from libthread_db resolved by dlopen(). */
187 static td_log_ftype
*p_td_log
;
188 static td_ta_new_ftype
*p_td_ta_new
;
189 static td_ta_delete_ftype
*p_td_ta_delete
;
190 static td_init_ftype
*p_td_init
;
191 static td_ta_get_ph_ftype
*p_td_ta_get_ph
;
192 static td_ta_get_nthreads_ftype
*p_td_ta_get_nthreads
;
193 static td_ta_tsd_iter_ftype
*p_td_ta_tsd_iter
;
194 static td_ta_thr_iter_ftype
*p_td_ta_thr_iter
;
195 static td_thr_validate_ftype
*p_td_thr_validate
;
196 static td_thr_tsd_ftype
*p_td_thr_tsd
;
197 static td_thr_get_info_ftype
*p_td_thr_get_info
;
198 static td_thr_getfpregs_ftype
*p_td_thr_getfpregs
;
199 static td_thr_getxregsize_ftype
*p_td_thr_getxregsize
;
200 static td_thr_getxregs_ftype
*p_td_thr_getxregs
;
201 static td_thr_sigsetmask_ftype
*p_td_thr_sigsetmask
;
202 static td_thr_setprio_ftype
*p_td_thr_setprio
;
203 static td_thr_setsigpending_ftype
*p_td_thr_setsigpending
;
204 static td_thr_setfpregs_ftype
*p_td_thr_setfpregs
;
205 static td_thr_setxregs_ftype
*p_td_thr_setxregs
;
206 static td_ta_map_id2thr_ftype
*p_td_ta_map_id2thr
;
207 static td_ta_map_lwp2thr_ftype
*p_td_ta_map_lwp2thr
;
208 static td_thr_getgregs_ftype
*p_td_thr_getgregs
;
209 static td_thr_setgregs_ftype
*p_td_thr_setgregs
;
212 /* Return the libthread_db error string associated with ERRCODE. If
213 ERRCODE is unknown, return an appropriate message. */
216 td_err_string (td_err_e errcode
)
218 static struct string_map td_err_table
[] =
220 { TD_OK
, "generic \"call succeeded\"" },
221 { TD_ERR
, "generic error." },
222 { TD_NOTHR
, "no thread can be found to satisfy query" },
223 { TD_NOSV
, "no synch. variable can be found to satisfy query" },
224 { TD_NOLWP
, "no lwp can be found to satisfy query" },
225 { TD_BADPH
, "invalid process handle" },
226 { TD_BADTH
, "invalid thread handle" },
227 { TD_BADSH
, "invalid synchronization handle" },
228 { TD_BADTA
, "invalid thread agent" },
229 { TD_BADKEY
, "invalid key" },
230 { TD_NOMSG
, "td_thr_event_getmsg() called when there was no message" },
231 { TD_NOFPREGS
, "FPU register set not available for given thread" },
232 { TD_NOLIBTHREAD
, "application not linked with libthread" },
233 { TD_NOEVENT
, "requested event is not supported" },
234 { TD_NOCAPAB
, "capability not available" },
235 { TD_DBERR
, "Debugger service failed" },
236 { TD_NOAPLIC
, "Operation not applicable to" },
237 { TD_NOTSD
, "No thread specific data for this thread" },
238 { TD_MALLOC
, "Malloc failed" },
239 { TD_PARTIALREG
, "Only part of register set was written/read" },
240 { TD_NOXREGS
, "X register set not available for given thread" }
242 const int td_err_size
= sizeof td_err_table
/ sizeof (struct string_map
);
246 for (i
= 0; i
< td_err_size
; i
++)
247 if (td_err_table
[i
].num
== errcode
)
248 return td_err_table
[i
].str
;
250 xsnprintf (buf
, sizeof (buf
), "Unknown libthread_db error code: %d",
256 /* Return the libthread_db state string associated with STATECODE.
257 If STATECODE is unknown, return an appropriate message. */
260 td_state_string (td_thr_state_e statecode
)
262 static struct string_map td_thr_state_table
[] =
264 { TD_THR_ANY_STATE
, "any state" },
265 { TD_THR_UNKNOWN
, "unknown" },
266 { TD_THR_STOPPED
, "stopped" },
267 { TD_THR_RUN
, "run" },
268 { TD_THR_ACTIVE
, "active" },
269 { TD_THR_ZOMBIE
, "zombie" },
270 { TD_THR_SLEEP
, "sleep" },
271 { TD_THR_STOPPED_ASLEEP
, "stopped asleep" }
273 const int td_thr_state_table_size
=
274 sizeof td_thr_state_table
/ sizeof (struct string_map
);
278 for (i
= 0; i
< td_thr_state_table_size
; i
++)
279 if (td_thr_state_table
[i
].num
== statecode
)
280 return td_thr_state_table
[i
].str
;
282 xsnprintf (buf
, sizeof (buf
), "Unknown libthread_db state code: %d",
289 /* Convert a POSIX or Solaris thread ID into a LWP ID. If THREAD_ID
290 doesn't exist, that's an error. If it's an inactive thread, return
293 NOTE: This function probably shouldn't call error(). */
296 thread_to_lwp (ptid_t thread_id
, int default_lwp
)
302 if (thread_id
.lwp_p ())
303 return thread_id
; /* It's already an LWP ID. */
305 /* It's a thread. Convert to LWP. */
307 val
= p_td_ta_map_id2thr (main_ta
, thread_id
.tid (), &th
);
309 return ptid_t (-1); /* Thread must have terminated. */
310 else if (val
!= TD_OK
)
311 error (_("thread_to_lwp: td_ta_map_id2thr %s"), td_err_string (val
));
313 val
= p_td_thr_get_info (&th
, &ti
);
315 return ptid_t (-1); /* Thread must have terminated. */
316 else if (val
!= TD_OK
)
317 error (_("thread_to_lwp: td_thr_get_info: %s"), td_err_string (val
));
319 if (ti
.ti_state
!= TD_THR_ACTIVE
)
321 if (default_lwp
!= -1)
322 return ptid_t (default_lwp
);
323 error (_("thread_to_lwp: thread state not active: %s"),
324 td_state_string (ti
.ti_state
));
327 return ptid_t (thread_id
.pid (), ti
.ti_lid
, 0);
330 /* Convert an LWP ID into a POSIX or Solaris thread ID. If LWP_ID
331 doesn't exists, that's an error.
333 NOTE: This function probably shouldn't call error(). */
336 lwp_to_thread (ptid_t lwp
)
343 return lwp
; /* It's already a thread ID. */
345 /* It's an LWP. Convert it to a thread ID. */
347 if (!target_thread_alive (lwp
))
348 return ptid_t (-1); /* Must be a defunct LPW. */
350 val
= p_td_ta_map_lwp2thr (main_ta
, lwp
.lwp (), &th
);
352 return ptid_t (-1); /* Thread must have terminated. */
353 else if (val
!= TD_OK
)
354 error (_("lwp_to_thread: td_ta_map_lwp2thr: %s."), td_err_string (val
));
356 val
= p_td_thr_validate (&th
);
358 return lwp
; /* Unknown to libthread; just return LPW, */
359 else if (val
!= TD_OK
)
360 error (_("lwp_to_thread: td_thr_validate: %s."), td_err_string (val
));
362 val
= p_td_thr_get_info (&th
, &ti
);
364 return ptid_t (-1); /* Thread must have terminated. */
365 else if (val
!= TD_OK
)
366 error (_("lwp_to_thread: td_thr_get_info: %s."), td_err_string (val
));
368 return ptid_t (lwp
.pid (), 0 , ti
.ti_tid
);
372 /* Most target vector functions from here on actually just pass
373 through to the layer beneath, as they don't need to do anything
374 specific for threads. */
376 /* Take a program previously attached to and detaches it. The program
377 resumes execution and will no longer stop on signals, etc. We'd
378 better not have left any breakpoints in the program or it'll die
379 when it hits one. For this to work, it may be necessary for the
380 process to have been previously attached. It *might* work if the
381 program was started via the normal ptrace (PTRACE_TRACEME). */
384 sol_thread_target::detach (inferior
*inf
, int from_tty
)
386 target_ops
*beneath
= this->beneath ();
388 sol_thread_active
= 0;
389 inferior_ptid
= ptid_t (main_ph
.ptid
.pid ());
390 unpush_target (this);
391 beneath
->detach (inf
, from_tty
);
394 /* Resume execution of process PTID. If STEP is nonzero, then just
395 single step it. If SIGNAL is nonzero, restart it with that signal
396 activated. We may have to convert PTID from a thread ID to an LWP
400 sol_thread_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
402 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
404 inferior_ptid
= thread_to_lwp (inferior_ptid
, main_ph
.ptid
.pid ());
405 if (inferior_ptid
.pid () == -1)
406 inferior_ptid
= procfs_first_available ();
408 if (ptid
.pid () != -1)
410 ptid_t save_ptid
= ptid
;
412 ptid
= thread_to_lwp (ptid
, -2);
413 if (ptid
.pid () == -2) /* Inactive thread. */
414 error (_("This version of Solaris can't start inactive threads."));
415 if (info_verbose
&& ptid
.pid () == -1)
416 warning (_("Specified thread %ld seems to have terminated"),
420 beneath ()->resume (ptid
, step
, signo
);
423 /* Wait for any threads to stop. We may have to convert PTID from a
424 thread ID to an LWP ID, and vice versa on the way out. */
427 sol_thread_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
433 save_ptid
= inferior_ptid
;
434 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
436 inferior_ptid
= thread_to_lwp (inferior_ptid
, main_ph
.ptid
.pid ());
437 if (inferior_ptid
.pid () == -1)
438 inferior_ptid
= procfs_first_available ();
440 if (ptid
.pid () != -1)
442 ptid_t ptid_for_warning
= ptid
;
444 ptid
= thread_to_lwp (ptid
, -2);
445 if (ptid
.pid () == -2) /* Inactive thread. */
446 error (_("This version of Solaris can't start inactive threads."));
447 if (info_verbose
&& ptid
.pid () == -1)
448 warning (_("Specified thread %ld seems to have terminated"),
449 ptid_for_warning
.tid ());
452 rtnval
= beneath ()->wait (ptid
, ourstatus
, options
);
454 if (ourstatus
->kind
!= TARGET_WAITKIND_EXITED
)
456 /* Map the LWP of interest back to the appropriate thread ID. */
457 rtnval
= lwp_to_thread (rtnval
);
458 if (rtnval
.pid () == -1)
461 /* See if we have a new thread. */
462 if (rtnval
.tid_p () && rtnval
!= save_ptid
)
464 thread_info
*thr
= find_thread_ptid (current_inferior (), rtnval
);
465 if (thr
== NULL
|| thr
->state
== THREAD_EXITED
)
467 process_stratum_target
*proc_target
468 = current_inferior ()->process_target ();
469 add_thread (proc_target
, rtnval
);
474 /* During process initialization, we may get here without the thread
475 package being initialized, since that can only happen after we've
476 found the shared libs. */
482 sol_thread_target::fetch_registers (struct regcache
*regcache
, int regnum
)
485 td_thrhandle_t thandle
;
488 prfpregset_t fpregset
;
489 gdb_gregset_t
*gregset_p
= &gregset
;
490 gdb_fpregset_t
*fpregset_p
= &fpregset
;
491 ptid_t ptid
= regcache
->ptid ();
495 /* It's an LWP; pass the request on to the layer beneath. */
496 beneath ()->fetch_registers (regcache
, regnum
);
500 /* Solaris thread: convert PTID into a td_thrhandle_t. */
501 thread
= ptid
.tid ();
503 error (_("sol_thread_fetch_registers: thread == 0"));
505 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
507 error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"),
508 td_err_string (val
));
510 /* Get the general-purpose registers. */
512 val
= p_td_thr_getgregs (&thandle
, gregset
);
513 if (val
!= TD_OK
&& val
!= TD_PARTIALREG
)
514 error (_("sol_thread_fetch_registers: td_thr_getgregs %s"),
515 td_err_string (val
));
517 /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
518 and %sp are saved (by a thread context switch). */
520 /* And, now the floating-point registers. */
522 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
523 if (val
!= TD_OK
&& val
!= TD_NOFPREGS
)
524 error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"),
525 td_err_string (val
));
527 /* Note that we must call supply_gregset and supply_fpregset *after*
528 calling the td routines because the td routines call ps_lget*
529 which affect the values stored in the registers array. */
531 supply_gregset (regcache
, (const gdb_gregset_t
*) gregset_p
);
532 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregset_p
);
536 sol_thread_target::store_registers (struct regcache
*regcache
, int regnum
)
539 td_thrhandle_t thandle
;
542 prfpregset_t fpregset
;
543 ptid_t ptid
= regcache
->ptid ();
547 /* It's an LWP; pass the request on to the layer beneath. */
548 beneath ()->store_registers (regcache
, regnum
);
552 /* Solaris thread: convert PTID into a td_thrhandle_t. */
553 thread
= ptid
.tid ();
555 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
557 error (_("sol_thread_store_registers: td_ta_map_id2thr %s"),
558 td_err_string (val
));
562 val
= p_td_thr_getgregs (&thandle
, gregset
);
564 error (_("sol_thread_store_registers: td_thr_getgregs %s"),
565 td_err_string (val
));
566 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
568 error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
569 td_err_string (val
));
572 fill_gregset (regcache
, (gdb_gregset_t
*) &gregset
, regnum
);
573 fill_fpregset (regcache
, (gdb_fpregset_t
*) &fpregset
, regnum
);
575 val
= p_td_thr_setgregs (&thandle
, gregset
);
577 error (_("sol_thread_store_registers: td_thr_setgregs %s"),
578 td_err_string (val
));
579 val
= p_td_thr_setfpregs (&thandle
, &fpregset
);
581 error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
582 td_err_string (val
));
585 /* Perform partial transfers on OBJECT. See target_read_partial and
586 target_write_partial for details of each variant. One, and only
587 one, of readbuf or writebuf must be non-NULL. */
589 enum target_xfer_status
590 sol_thread_target::xfer_partial (enum target_object object
,
591 const char *annex
, gdb_byte
*readbuf
,
592 const gdb_byte
*writebuf
,
593 ULONGEST offset
, ULONGEST len
,
594 ULONGEST
*xfered_len
)
596 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
598 if (inferior_ptid
.tid_p () || !target_thread_alive (inferior_ptid
))
600 /* It's either a thread or an LWP that isn't alive. Any live
601 LWP will do so use the first available.
603 NOTE: We don't need to call switch_to_thread; we're just
605 inferior_ptid
= procfs_first_available ();
608 return beneath ()->xfer_partial (object
, annex
, readbuf
,
609 writebuf
, offset
, len
, xfered_len
);
613 check_for_thread_db (void)
618 /* Don't attempt to use thread_db for remote targets. */
619 if (!(target_can_run () || core_bfd
))
622 /* Do nothing if we couldn't load libthread_db.so.1. */
623 if (p_td_ta_new
== NULL
)
626 if (sol_thread_active
)
627 /* Nothing to do. The thread library was already detected and the
628 target vector was already activated. */
631 /* Now, initialize libthread_db. This needs to be done after the
632 shared libraries are located because it needs information from
633 the user's thread library. */
638 warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (err
));
642 /* Now attempt to open a connection to the thread library. */
643 err
= p_td_ta_new (&main_ph
, &main_ta
);
647 /* No thread library was detected. */
651 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
653 /* The thread library was detected. Activate the sol_thread target. */
654 push_target (&sol_thread_ops
);
655 sol_thread_active
= 1;
657 main_ph
.ptid
= inferior_ptid
; /* Save for xfer_memory. */
658 ptid
= lwp_to_thread (inferior_ptid
);
659 if (ptid
.pid () != -1)
660 inferior_ptid
= ptid
;
662 target_update_thread_list ();
666 warning (_("Cannot initialize thread debugging library: %s"),
667 td_err_string (err
));
672 /* This routine is called whenever a new symbol table is read in, or
673 when all symbol tables are removed. libthread_db can only be
674 initialized when it finds the right variables in libthread.so.
675 Since it's a shared library, those variables don't show up until
676 the library gets mapped and the symbol table is read in. */
679 sol_thread_new_objfile (struct objfile
*objfile
)
682 check_for_thread_db ();
685 /* Clean up after the inferior dies. */
688 sol_thread_target::mourn_inferior ()
690 target_ops
*beneath
= this->beneath ();
692 sol_thread_active
= 0;
694 unpush_target (this);
696 beneath
->mourn_inferior ();
699 /* Return true if PTID is still active in the inferior. */
702 sol_thread_target::thread_alive (ptid_t ptid
)
706 /* It's a (user-level) thread. */
712 val
= p_td_ta_map_id2thr (main_ta
, pid
, &th
);
714 return false; /* Thread not found. */
715 val
= p_td_thr_validate (&th
);
717 return false; /* Thread not valid. */
718 return true; /* Known thread. */
722 /* It's an LPW; pass the request on to the layer below. */
723 return beneath ()->thread_alive (ptid
);
728 /* These routines implement the lower half of the thread_db interface,
729 i.e. the ps_* routines. */
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 (struct ps_prochandle
*ph
)
744 /* Process continue. */
747 ps_pcontinue (struct ps_prochandle
*ph
)
755 ps_lstop (struct ps_prochandle
*ph
, lwpid_t lwpid
)
763 ps_lcontinue (struct ps_prochandle
*ph
, lwpid_t lwpid
)
768 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
771 ps_pglobal_lookup (struct ps_prochandle
*ph
, const char *ld_object_name
,
772 const char *ld_symbol_name
, psaddr_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
, psaddr_t addr
,
788 gdb_byte
*buf
, int size
)
792 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
794 if (inferior_ptid
.tid_p () || !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 (struct ps_prochandle
*ph
, psaddr_t addr
, void *buf
, size_t size
)
824 return rw_common (0, ph
, addr
, (gdb_byte
*) buf
, size
);
827 /* Copies SIZE bytes from debugger memory .data segment to target process. */
830 ps_pdwrite (struct ps_prochandle
*ph
, psaddr_t addr
,
831 const void *buf
, size_t size
)
833 return rw_common (1, ph
, addr
, (gdb_byte
*) buf
, size
);
836 /* Copies SIZE bytes from target process .text segment to debugger memory. */
839 ps_ptread (struct ps_prochandle
*ph
, psaddr_t addr
, void *buf
, size_t size
)
841 return rw_common (0, ph
, addr
, (gdb_byte
*) buf
, size
);
844 /* Copies SIZE bytes from debugger memory .text segment to target process. */
847 ps_ptwrite (struct ps_prochandle
*ph
, psaddr_t addr
,
848 const void *buf
, size_t size
)
850 return rw_common (1, ph
, addr
, (gdb_byte
*) buf
, size
);
853 /* Get general-purpose registers for LWP. */
856 ps_lgetregs (struct ps_prochandle
*ph
, lwpid_t lwpid
, prgregset_t gregset
)
858 ptid_t ptid
= ptid_t (inferior_ptid
.pid (), lwpid
, 0);
859 struct regcache
*regcache
860 = get_thread_arch_regcache (current_inferior ()->process_target (),
861 ptid
, target_gdbarch ());
863 target_fetch_registers (regcache
, -1);
864 fill_gregset (regcache
, (gdb_gregset_t
*) gregset
, -1);
869 /* Set general-purpose registers for LWP. */
872 ps_lsetregs (struct ps_prochandle
*ph
, lwpid_t lwpid
,
873 const prgregset_t gregset
)
875 ptid_t ptid
= ptid_t (inferior_ptid
.pid (), lwpid
, 0);
876 struct regcache
*regcache
877 = get_thread_arch_regcache (current_inferior ()->process_target (),
878 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 (struct ps_prochandle
*ph
, lwpid_t lwpid
, int *xregsize
)
906 /* Get extra register set. Currently a noop. */
909 ps_lgetxregs (struct ps_prochandle
*ph
, lwpid_t lwpid
, caddr_t xregset
)
914 /* Set extra register set. Currently a noop. */
917 ps_lsetxregs (struct ps_prochandle
*ph
, lwpid_t lwpid
, caddr_t xregset
)
922 /* Get floating-point registers for LWP. */
925 ps_lgetfpregs (struct ps_prochandle
*ph
, lwpid_t lwpid
,
926 prfpregset_t
*fpregset
)
928 ptid_t ptid
= ptid_t (inferior_ptid
.pid (), lwpid
, 0);
929 struct regcache
*regcache
930 = get_thread_arch_regcache (current_inferior ()->process_target (),
931 ptid
, target_gdbarch ());
933 target_fetch_registers (regcache
, -1);
934 fill_fpregset (regcache
, (gdb_fpregset_t
*) fpregset
, -1);
939 /* Set floating-point regs for LWP. */
942 ps_lsetfpregs (struct ps_prochandle
*ph
, lwpid_t lwpid
,
943 const prfpregset_t
* fpregset
)
945 ptid_t ptid
= ptid_t (inferior_ptid
.pid (), lwpid
, 0);
946 struct regcache
*regcache
947 = get_thread_arch_regcache (current_inferior ()->process_target (),
948 ptid
, target_gdbarch ());
950 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregset
);
951 target_store_registers (regcache
, -1);
956 /* Identify process as 32-bit or 64-bit. At the moment we're using
957 BFD to do this. There might be a more Solaris-specific
958 (e.g. procfs) method, but this ought to work. */
961 ps_pdmodel (struct ps_prochandle
*ph
, int *data_model
)
964 *data_model
= PR_MODEL_UNKNOWN
;
965 else if (bfd_get_arch_size (exec_bfd
) == 32)
966 *data_model
= PR_MODEL_ILP32
;
968 *data_model
= 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 (struct ps_prochandle
*ph
, lwpid_t lwpid
, struct ssd
*pldt
) /* ARI: editCase function */
983 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */
986 /* FIXME: can't I get the process ID from the prochandle or
989 if (inferior_ptid
.pid () <= 0 || lwpid
<= 0)
992 ret
= procfs_find_LDT_entry (ptid_t (inferior_ptid
.pid (),
996 memcpy (pldt
, ret
, sizeof (struct ssd
));
1000 /* LDT not found. */
1006 /* Convert PTID to printable form. */
1009 sol_thread_target::pid_to_str (ptid_t ptid
)
1015 lwp
= thread_to_lwp (ptid
, -2);
1017 if (lwp
.pid () == -1)
1018 return string_printf ("Thread %ld (defunct)",
1020 else if (lwp
.pid () != -2)
1021 return string_printf ("Thread %ld (LWP %ld)",
1022 ptid
.tid (), lwp
.lwp ());
1024 return string_printf ("Thread %ld ",
1027 else if (ptid
.lwp () != 0)
1028 return string_printf ("LWP %ld ", ptid
.lwp ());
1030 return string_printf ("process %d ", ptid
.pid ());
1034 /* Worker bee for update_thread_list. Callback function that gets
1035 called once per user-level thread (i.e. not for LWP's). */
1038 sol_update_thread_list_callback (const td_thrhandle_t
*th
, void *ignored
)
1043 retval
= p_td_thr_get_info (th
, &ti
);
1044 if (retval
!= TD_OK
)
1047 ptid_t ptid
= ptid_t (inferior_ptid
.pid (), 0, ti
.ti_tid
);
1048 thread_info
*thr
= find_thread_ptid (current_inferior (), ptid
);
1049 if (thr
== NULL
|| thr
->state
== THREAD_EXITED
)
1051 process_stratum_target
*proc_target
1052 = current_inferior ()->process_target ();
1053 add_thread (proc_target
, ptid
);
1060 sol_thread_target::update_thread_list ()
1062 /* Delete dead threads. */
1065 /* Find any new LWP's. */
1066 beneath ()->update_thread_list ();
1068 /* Then find any new user-level threads. */
1069 p_td_ta_thr_iter (main_ta
, sol_update_thread_list_callback
, (void *) 0,
1070 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1071 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1074 /* Worker bee for the "info sol-thread" command. This is a callback
1075 function that gets called once for each Solaris user-level thread
1076 (i.e. not for LWPs) in the inferior. Print anything interesting
1077 that we can think of. */
1080 info_cb (const td_thrhandle_t
*th
, void *s
)
1085 ret
= p_td_thr_get_info (th
, &ti
);
1088 printf_filtered ("%s thread #%d, lwp %d, ",
1089 ti
.ti_type
== TD_THR_SYSTEM
? "system" : "user ",
1090 ti
.ti_tid
, ti
.ti_lid
);
1091 switch (ti
.ti_state
)
1094 case TD_THR_UNKNOWN
:
1095 printf_filtered ("<unknown state>");
1097 case TD_THR_STOPPED
:
1098 printf_filtered ("(stopped)");
1101 printf_filtered ("(run) ");
1104 printf_filtered ("(active) ");
1107 printf_filtered ("(zombie) ");
1110 printf_filtered ("(asleep) ");
1112 case TD_THR_STOPPED_ASLEEP
:
1113 printf_filtered ("(stopped asleep)");
1116 /* Print thr_create start function. */
1117 if (ti
.ti_startfunc
!= 0)
1119 const struct bound_minimal_symbol msym
1120 = lookup_minimal_symbol_by_pc (ti
.ti_startfunc
);
1122 printf_filtered (" startfunc=%s",
1124 ? msym
.minsym
->print_name ()
1125 : paddress (target_gdbarch (), ti
.ti_startfunc
));
1128 /* If thread is asleep, print function that went to sleep. */
1129 if (ti
.ti_state
== TD_THR_SLEEP
)
1131 const struct bound_minimal_symbol msym
1132 = lookup_minimal_symbol_by_pc (ti
.ti_pc
);
1134 printf_filtered (" sleepfunc=%s",
1136 ? msym
.minsym
->print_name ()
1137 : paddress (target_gdbarch (), ti
.ti_pc
));
1140 printf_filtered ("\n");
1143 warning (_("info sol-thread: failed to get info for thread."));
1148 /* List some state about each Solaris user-level thread in the
1152 info_solthreads (const char *args
, int from_tty
)
1154 p_td_ta_thr_iter (main_ta
, info_cb
, (void *) args
,
1155 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1156 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1159 /* Callback routine used to find a thread based on the TID part of
1163 thread_db_find_thread_from_tid (struct thread_info
*thread
, void *data
)
1165 long *tid
= (long *) data
;
1167 if (thread
->ptid
.tid () == *tid
)
1174 sol_thread_target::get_ada_task_ptid (long lwp
, long thread
)
1176 struct thread_info
*thread_info
=
1177 iterate_over_threads (thread_db_find_thread_from_tid
, &thread
);
1179 if (thread_info
== NULL
)
1181 /* The list of threads is probably not up to date. Find any
1182 thread that is missing from the list, and try again. */
1183 update_thread_list ();
1184 thread_info
= iterate_over_threads (thread_db_find_thread_from_tid
,
1188 gdb_assert (thread_info
!= NULL
);
1190 return (thread_info
->ptid
);
1193 void _initialize_sol_thread ();
1195 _initialize_sol_thread ()
1199 dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
);
1203 #define resolve(X) \
1204 if (!(p_##X = (X ## _ftype *) dlsym (dlhandle, #X))) \
1208 resolve (td_ta_new
);
1209 resolve (td_ta_delete
);
1211 resolve (td_ta_get_ph
);
1212 resolve (td_ta_get_nthreads
);
1213 resolve (td_ta_tsd_iter
);
1214 resolve (td_ta_thr_iter
);
1215 resolve (td_thr_validate
);
1216 resolve (td_thr_tsd
);
1217 resolve (td_thr_get_info
);
1218 resolve (td_thr_getfpregs
);
1219 resolve (td_thr_getxregsize
);
1220 resolve (td_thr_getxregs
);
1221 resolve (td_thr_sigsetmask
);
1222 resolve (td_thr_setprio
);
1223 resolve (td_thr_setsigpending
);
1224 resolve (td_thr_setfpregs
);
1225 resolve (td_thr_setxregs
);
1226 resolve (td_ta_map_id2thr
);
1227 resolve (td_ta_map_lwp2thr
);
1228 resolve (td_thr_getgregs
);
1229 resolve (td_thr_setgregs
);
1231 add_cmd ("sol-threads", class_maintenance
, info_solthreads
,
1232 _("Show info on Solaris user threads."), &maintenanceinfolist
);
1234 /* Hook into new_objfile notification. */
1235 gdb::observers::new_objfile
.attach (sol_thread_new_objfile
);
1239 fprintf_unfiltered (gdb_stderr
, "\
1240 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ());