1 /* Solaris threads debugging interface.
3 Copyright (C) 1996-2019 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 (rtnval
);
465 if (thr
== NULL
|| thr
->state
== THREAD_EXITED
)
470 /* During process initialization, we may get here without the thread
471 package being initialized, since that can only happen after we've
472 found the shared libs. */
478 sol_thread_target::fetch_registers (struct regcache
*regcache
, int regnum
)
481 td_thrhandle_t thandle
;
484 prfpregset_t fpregset
;
485 gdb_gregset_t
*gregset_p
= &gregset
;
486 gdb_fpregset_t
*fpregset_p
= &fpregset
;
487 ptid_t ptid
= regcache
->ptid ();
491 /* It's an LWP; pass the request on to the layer beneath. */
492 beneath ()->fetch_registers (regcache
, regnum
);
496 /* Solaris thread: convert PTID into a td_thrhandle_t. */
497 thread
= ptid
.tid ();
499 error (_("sol_thread_fetch_registers: thread == 0"));
501 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
503 error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"),
504 td_err_string (val
));
506 /* Get the general-purpose registers. */
508 val
= p_td_thr_getgregs (&thandle
, gregset
);
509 if (val
!= TD_OK
&& val
!= TD_PARTIALREG
)
510 error (_("sol_thread_fetch_registers: td_thr_getgregs %s"),
511 td_err_string (val
));
513 /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
514 and %sp are saved (by a thread context switch). */
516 /* And, now the floating-point registers. */
518 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
519 if (val
!= TD_OK
&& val
!= TD_NOFPREGS
)
520 error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"),
521 td_err_string (val
));
523 /* Note that we must call supply_gregset and supply_fpregset *after*
524 calling the td routines because the td routines call ps_lget*
525 which affect the values stored in the registers array. */
527 supply_gregset (regcache
, (const gdb_gregset_t
*) gregset_p
);
528 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregset_p
);
532 sol_thread_target::store_registers (struct regcache
*regcache
, int regnum
)
535 td_thrhandle_t thandle
;
538 prfpregset_t fpregset
;
539 ptid_t ptid
= regcache
->ptid ();
543 /* It's an LWP; pass the request on to the layer beneath. */
544 beneath ()->store_registers (regcache
, regnum
);
548 /* Solaris thread: convert PTID into a td_thrhandle_t. */
549 thread
= ptid
.tid ();
551 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
553 error (_("sol_thread_store_registers: td_ta_map_id2thr %s"),
554 td_err_string (val
));
558 val
= p_td_thr_getgregs (&thandle
, gregset
);
560 error (_("sol_thread_store_registers: td_thr_getgregs %s"),
561 td_err_string (val
));
562 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
564 error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
565 td_err_string (val
));
568 fill_gregset (regcache
, (gdb_gregset_t
*) &gregset
, regnum
);
569 fill_fpregset (regcache
, (gdb_fpregset_t
*) &fpregset
, regnum
);
571 val
= p_td_thr_setgregs (&thandle
, gregset
);
573 error (_("sol_thread_store_registers: td_thr_setgregs %s"),
574 td_err_string (val
));
575 val
= p_td_thr_setfpregs (&thandle
, &fpregset
);
577 error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
578 td_err_string (val
));
581 /* Perform partial transfers on OBJECT. See target_read_partial and
582 target_write_partial for details of each variant. One, and only
583 one, of readbuf or writebuf must be non-NULL. */
585 enum target_xfer_status
586 sol_thread_target::xfer_partial (enum target_object object
,
587 const char *annex
, gdb_byte
*readbuf
,
588 const gdb_byte
*writebuf
,
589 ULONGEST offset
, ULONGEST len
,
590 ULONGEST
*xfered_len
)
592 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
594 if (inferior_ptid
.tid_p () || !target_thread_alive (inferior_ptid
))
596 /* It's either a thread or an LWP that isn't alive. Any live
597 LWP will do so use the first available.
599 NOTE: We don't need to call switch_to_thread; we're just
601 inferior_ptid
= procfs_first_available ();
604 return beneath ()->xfer_partial (object
, annex
, readbuf
,
605 writebuf
, offset
, len
, xfered_len
);
609 check_for_thread_db (void)
614 /* Don't attempt to use thread_db for remote targets. */
615 if (!(target_can_run () || core_bfd
))
618 /* Do nothing if we couldn't load libthread_db.so.1. */
619 if (p_td_ta_new
== NULL
)
622 if (sol_thread_active
)
623 /* Nothing to do. The thread library was already detected and the
624 target vector was already activated. */
627 /* Now, initialize libthread_db. This needs to be done after the
628 shared libraries are located because it needs information from
629 the user's thread library. */
634 warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (err
));
638 /* Now attempt to open a connection to the thread library. */
639 err
= p_td_ta_new (&main_ph
, &main_ta
);
643 /* No thread library was detected. */
647 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
649 /* The thread library was detected. Activate the sol_thread target. */
650 push_target (&sol_thread_ops
);
651 sol_thread_active
= 1;
653 main_ph
.ptid
= inferior_ptid
; /* Save for xfer_memory. */
654 ptid
= lwp_to_thread (inferior_ptid
);
655 if (ptid
.pid () != -1)
656 inferior_ptid
= ptid
;
658 target_update_thread_list ();
662 warning (_("Cannot initialize thread debugging library: %s"),
663 td_err_string (err
));
668 /* This routine is called whenever a new symbol table is read in, or
669 when all symbol tables are removed. libthread_db can only be
670 initialized when it finds the right variables in libthread.so.
671 Since it's a shared library, those variables don't show up until
672 the library gets mapped and the symbol table is read in. */
675 sol_thread_new_objfile (struct objfile
*objfile
)
678 check_for_thread_db ();
681 /* Clean up after the inferior dies. */
684 sol_thread_target::mourn_inferior ()
686 target_ops
*beneath
= this->beneath ();
688 sol_thread_active
= 0;
690 unpush_target (this);
692 beneath
->mourn_inferior ();
695 /* Return true if PTID is still active in the inferior. */
698 sol_thread_target::thread_alive (ptid_t ptid
)
702 /* It's a (user-level) thread. */
708 val
= p_td_ta_map_id2thr (main_ta
, pid
, &th
);
710 return false; /* Thread not found. */
711 val
= p_td_thr_validate (&th
);
713 return false; /* Thread not valid. */
714 return true; /* Known thread. */
718 /* It's an LPW; pass the request on to the layer below. */
719 return beneath ()->thread_alive (ptid
);
724 /* These routines implement the lower half of the thread_db interface,
725 i.e. the ps_* routines. */
727 /* The next four routines are called by libthread_db to tell us to
728 stop and stop a particular process or lwp. Since GDB ensures that
729 these are all stopped by the time we call anything in thread_db,
730 these routines need to do nothing. */
735 ps_pstop (struct ps_prochandle
*ph
)
740 /* Process continue. */
743 ps_pcontinue (struct ps_prochandle
*ph
)
751 ps_lstop (struct ps_prochandle
*ph
, lwpid_t lwpid
)
759 ps_lcontinue (struct ps_prochandle
*ph
, lwpid_t lwpid
)
764 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
767 ps_pglobal_lookup (struct ps_prochandle
*ph
, const char *ld_object_name
,
768 const char *ld_symbol_name
, psaddr_t
*ld_symbol_addr
)
770 struct bound_minimal_symbol ms
;
772 ms
= lookup_minimal_symbol (ld_symbol_name
, NULL
, NULL
);
776 *ld_symbol_addr
= BMSYMBOL_VALUE_ADDRESS (ms
);
780 /* Common routine for reading and writing memory. */
783 rw_common (int dowrite
, const struct ps_prochandle
*ph
, psaddr_t addr
,
784 gdb_byte
*buf
, int size
)
788 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
790 if (inferior_ptid
.tid_p () || !target_thread_alive (inferior_ptid
))
792 /* It's either a thread or an LWP that isn't alive. Any live
793 LWP will do so use the first available.
795 NOTE: We don't need to call switch_to_thread; we're just
797 inferior_ptid
= procfs_first_available ();
800 #if defined (__sparcv9)
801 /* For Sparc64 cross Sparc32, make sure the address has not been
802 accidentally sign-extended (or whatever) to beyond 32 bits. */
803 if (bfd_get_arch_size (exec_bfd
) == 32)
808 ret
= target_write_memory (addr
, (gdb_byte
*) buf
, size
);
810 ret
= target_read_memory (addr
, (gdb_byte
*) buf
, size
);
812 return (ret
== 0 ? PS_OK
: PS_ERR
);
815 /* Copies SIZE bytes from target process .data segment to debugger memory. */
818 ps_pdread (struct ps_prochandle
*ph
, psaddr_t addr
, void *buf
, size_t size
)
820 return rw_common (0, ph
, addr
, (gdb_byte
*) buf
, size
);
823 /* Copies SIZE bytes from debugger memory .data segment to target process. */
826 ps_pdwrite (struct ps_prochandle
*ph
, psaddr_t addr
,
827 const void *buf
, size_t size
)
829 return rw_common (1, ph
, addr
, (gdb_byte
*) buf
, size
);
832 /* Copies SIZE bytes from target process .text segment to debugger memory. */
835 ps_ptread (struct ps_prochandle
*ph
, psaddr_t addr
, void *buf
, size_t size
)
837 return rw_common (0, ph
, addr
, (gdb_byte
*) buf
, size
);
840 /* Copies SIZE bytes from debugger memory .text segment to target process. */
843 ps_ptwrite (struct ps_prochandle
*ph
, psaddr_t addr
,
844 const void *buf
, size_t size
)
846 return rw_common (1, ph
, addr
, (gdb_byte
*) buf
, size
);
849 /* Get general-purpose registers for LWP. */
852 ps_lgetregs (struct ps_prochandle
*ph
, lwpid_t lwpid
, prgregset_t gregset
)
854 ptid_t ptid
= ptid_t (inferior_ptid
.pid (), lwpid
, 0);
855 struct regcache
*regcache
856 = get_thread_arch_regcache (ptid
, target_gdbarch ());
858 target_fetch_registers (regcache
, -1);
859 fill_gregset (regcache
, (gdb_gregset_t
*) gregset
, -1);
864 /* Set general-purpose registers for LWP. */
867 ps_lsetregs (struct ps_prochandle
*ph
, lwpid_t lwpid
,
868 const prgregset_t gregset
)
870 ptid_t ptid
= ptid_t (inferior_ptid
.pid (), lwpid
, 0);
871 struct regcache
*regcache
872 = get_thread_arch_regcache (ptid
, target_gdbarch ());
874 supply_gregset (regcache
, (const gdb_gregset_t
*) gregset
);
875 target_store_registers (regcache
, -1);
880 /* Log a message (sends to gdb_stderr). */
883 ps_plog (const char *fmt
, ...)
887 va_start (args
, fmt
);
889 vfprintf_filtered (gdb_stderr
, fmt
, args
);
892 /* Get size of extra register set. Currently a noop. */
895 ps_lgetxregsize (struct ps_prochandle
*ph
, lwpid_t lwpid
, int *xregsize
)
900 /* Get extra register set. Currently a noop. */
903 ps_lgetxregs (struct ps_prochandle
*ph
, lwpid_t lwpid
, caddr_t xregset
)
908 /* Set extra register set. Currently a noop. */
911 ps_lsetxregs (struct ps_prochandle
*ph
, lwpid_t lwpid
, caddr_t xregset
)
916 /* Get floating-point registers for LWP. */
919 ps_lgetfpregs (struct ps_prochandle
*ph
, lwpid_t lwpid
,
920 prfpregset_t
*fpregset
)
922 ptid_t ptid
= ptid_t (inferior_ptid
.pid (), lwpid
, 0);
923 struct regcache
*regcache
924 = get_thread_arch_regcache (ptid
, target_gdbarch ());
926 target_fetch_registers (regcache
, -1);
927 fill_fpregset (regcache
, (gdb_fpregset_t
*) fpregset
, -1);
932 /* Set floating-point regs for LWP. */
935 ps_lsetfpregs (struct ps_prochandle
*ph
, lwpid_t lwpid
,
936 const prfpregset_t
* fpregset
)
938 ptid_t ptid
= ptid_t (inferior_ptid
.pid (), lwpid
, 0);
939 struct regcache
*regcache
940 = get_thread_arch_regcache (ptid
, target_gdbarch ());
942 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregset
);
943 target_store_registers (regcache
, -1);
948 /* Identify process as 32-bit or 64-bit. At the moment we're using
949 BFD to do this. There might be a more Solaris-specific
950 (e.g. procfs) method, but this ought to work. */
953 ps_pdmodel (struct ps_prochandle
*ph
, int *data_model
)
956 *data_model
= PR_MODEL_UNKNOWN
;
957 else if (bfd_get_arch_size (exec_bfd
) == 32)
958 *data_model
= PR_MODEL_ILP32
;
960 *data_model
= PR_MODEL_LP64
;
965 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
967 /* Reads the local descriptor table of a LWP.
969 This function is necessary on x86-solaris only. Without it, the loading
970 of libthread_db would fail because of ps_lgetLDT being undefined. */
973 ps_lgetLDT (struct ps_prochandle
*ph
, lwpid_t lwpid
, struct ssd
*pldt
) /* ARI: editCase function */
975 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */
978 /* FIXME: can't I get the process ID from the prochandle or
981 if (inferior_ptid
.pid () <= 0 || lwpid
<= 0)
984 ret
= procfs_find_LDT_entry (ptid_t (inferior_ptid
.pid (),
988 memcpy (pldt
, ret
, sizeof (struct ssd
));
998 /* Convert PTID to printable form. */
1001 sol_thread_target::pid_to_str (ptid_t ptid
)
1007 lwp
= thread_to_lwp (ptid
, -2);
1009 if (lwp
.pid () == -1)
1010 return string_printf ("Thread %ld (defunct)",
1012 else if (lwp
.pid () != -2)
1013 return string_printf ("Thread %ld (LWP %ld)",
1014 ptid
.tid (), lwp
.lwp ());
1016 return string_printf ("Thread %ld ",
1019 else if (ptid
.lwp () != 0)
1020 return string_printf ("LWP %ld ", ptid
.lwp ());
1022 return string_printf ("process %d ", ptid
.pid ());
1026 /* Worker bee for update_thread_list. Callback function that gets
1027 called once per user-level thread (i.e. not for LWP's). */
1030 sol_update_thread_list_callback (const td_thrhandle_t
*th
, void *ignored
)
1035 retval
= p_td_thr_get_info (th
, &ti
);
1036 if (retval
!= TD_OK
)
1039 ptid_t ptid
= ptid_t (inferior_ptid
.pid (), 0, ti
.ti_tid
);
1040 thread_info
*thr
= find_thread_ptid (ptid
);
1041 if (thr
== NULL
|| thr
->state
== THREAD_EXITED
)
1048 sol_thread_target::update_thread_list ()
1050 /* Delete dead threads. */
1053 /* Find any new LWP's. */
1054 beneath ()->update_thread_list ();
1056 /* Then find any new user-level threads. */
1057 p_td_ta_thr_iter (main_ta
, sol_update_thread_list_callback
, (void *) 0,
1058 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1059 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1062 /* Worker bee for the "info sol-thread" command. This is a callback
1063 function that gets called once for each Solaris user-level thread
1064 (i.e. not for LWPs) in the inferior. Print anything interesting
1065 that we can think of. */
1068 info_cb (const td_thrhandle_t
*th
, void *s
)
1073 ret
= p_td_thr_get_info (th
, &ti
);
1076 printf_filtered ("%s thread #%d, lwp %d, ",
1077 ti
.ti_type
== TD_THR_SYSTEM
? "system" : "user ",
1078 ti
.ti_tid
, ti
.ti_lid
);
1079 switch (ti
.ti_state
)
1082 case TD_THR_UNKNOWN
:
1083 printf_filtered ("<unknown state>");
1085 case TD_THR_STOPPED
:
1086 printf_filtered ("(stopped)");
1089 printf_filtered ("(run) ");
1092 printf_filtered ("(active) ");
1095 printf_filtered ("(zombie) ");
1098 printf_filtered ("(asleep) ");
1100 case TD_THR_STOPPED_ASLEEP
:
1101 printf_filtered ("(stopped asleep)");
1104 /* Print thr_create start function. */
1105 if (ti
.ti_startfunc
!= 0)
1107 const struct bound_minimal_symbol msym
1108 = lookup_minimal_symbol_by_pc (ti
.ti_startfunc
);
1110 printf_filtered (" startfunc=%s",
1112 ? msym
.minsym
->print_name ()
1113 : paddress (target_gdbarch (), ti
.ti_startfunc
));
1116 /* If thread is asleep, print function that went to sleep. */
1117 if (ti
.ti_state
== TD_THR_SLEEP
)
1119 const struct bound_minimal_symbol msym
1120 = lookup_minimal_symbol_by_pc (ti
.ti_pc
);
1122 printf_filtered (" sleepfunc=%s",
1124 ? msym
.minsym
->print_name ()
1125 : paddress (target_gdbarch (), ti
.ti_pc
));
1128 printf_filtered ("\n");
1131 warning (_("info sol-thread: failed to get info for thread."));
1136 /* List some state about each Solaris user-level thread in the
1140 info_solthreads (const char *args
, int from_tty
)
1142 p_td_ta_thr_iter (main_ta
, info_cb
, (void *) args
,
1143 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1144 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1147 /* Callback routine used to find a thread based on the TID part of
1151 thread_db_find_thread_from_tid (struct thread_info
*thread
, void *data
)
1153 long *tid
= (long *) data
;
1155 if (thread
->ptid
.tid () == *tid
)
1162 sol_thread_target::get_ada_task_ptid (long lwp
, long thread
)
1164 struct thread_info
*thread_info
=
1165 iterate_over_threads (thread_db_find_thread_from_tid
, &thread
);
1167 if (thread_info
== NULL
)
1169 /* The list of threads is probably not up to date. Find any
1170 thread that is missing from the list, and try again. */
1171 update_thread_list ();
1172 thread_info
= iterate_over_threads (thread_db_find_thread_from_tid
,
1176 gdb_assert (thread_info
!= NULL
);
1178 return (thread_info
->ptid
);
1182 _initialize_sol_thread (void)
1186 dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
);
1190 #define resolve(X) \
1191 if (!(p_##X = (X ## _ftype *) dlsym (dlhandle, #X))) \
1195 resolve (td_ta_new
);
1196 resolve (td_ta_delete
);
1198 resolve (td_ta_get_ph
);
1199 resolve (td_ta_get_nthreads
);
1200 resolve (td_ta_tsd_iter
);
1201 resolve (td_ta_thr_iter
);
1202 resolve (td_thr_validate
);
1203 resolve (td_thr_tsd
);
1204 resolve (td_thr_get_info
);
1205 resolve (td_thr_getfpregs
);
1206 resolve (td_thr_getxregsize
);
1207 resolve (td_thr_getxregs
);
1208 resolve (td_thr_sigsetmask
);
1209 resolve (td_thr_setprio
);
1210 resolve (td_thr_setsigpending
);
1211 resolve (td_thr_setfpregs
);
1212 resolve (td_thr_setxregs
);
1213 resolve (td_ta_map_id2thr
);
1214 resolve (td_ta_map_lwp2thr
);
1215 resolve (td_thr_getgregs
);
1216 resolve (td_thr_setgregs
);
1218 add_cmd ("sol-threads", class_maintenance
, info_solthreads
,
1219 _("Show info on Solaris user threads."), &maintenanceinfolist
);
1221 /* Hook into new_objfile notification. */
1222 gdb::observers::new_objfile
.attach (sol_thread_new_objfile
);
1226 fprintf_unfiltered (gdb_stderr
, "\
1227 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ());