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"
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
82 { this->to_stratum
= thread_stratum
; }
84 const target_info
&info () const override
85 { return thread_db_target_info
; }
87 void detach (inferior
*, int) override
;
88 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
89 void resume (ptid_t
, int, enum gdb_signal
) override
;
90 void mourn_inferior () override
;
91 const char *pid_to_str (ptid_t
) override
;
92 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
94 void fetch_registers (struct regcache
*, int) override
;
95 void store_registers (struct regcache
*, int) override
;
97 enum target_xfer_status
xfer_partial (enum target_object object
,
100 const gdb_byte
*writebuf
,
101 ULONGEST offset
, ULONGEST len
,
102 ULONGEST
*xfered_len
) override
;
104 bool thread_alive (ptid_t ptid
) override
;
105 void update_thread_list () override
;
108 static sol_thread_target sol_thread_ops
;
110 /* Prototypes for supply_gregset etc. */
113 /* This struct is defined by us, but mainly used for the proc_service
114 interface. We don't have much use for it, except as a handy place
115 to get a real PID for memory accesses. */
128 static struct ps_prochandle main_ph
;
129 static td_thragent_t
*main_ta
;
130 static int sol_thread_active
= 0;
132 /* Default definitions: These must be defined in tm.h if they are to
133 be shared with a process module such as procfs. */
135 /* Types of the libthread_db functions. */
137 typedef void (td_log_ftype
)(const int on_off
);
138 typedef td_err_e (td_ta_new_ftype
)(const struct ps_prochandle
*ph_p
,
139 td_thragent_t
**ta_pp
);
140 typedef td_err_e (td_ta_delete_ftype
)(td_thragent_t
*ta_p
);
141 typedef td_err_e (td_init_ftype
)(void);
142 typedef td_err_e (td_ta_get_ph_ftype
)(const td_thragent_t
*ta_p
,
143 struct ps_prochandle
**ph_pp
);
144 typedef td_err_e (td_ta_get_nthreads_ftype
)(const td_thragent_t
*ta_p
,
146 typedef td_err_e (td_ta_tsd_iter_ftype
)(const td_thragent_t
*ta_p
,
147 td_key_iter_f
*cb
, void *cbdata_p
);
148 typedef td_err_e (td_ta_thr_iter_ftype
)(const td_thragent_t
*ta_p
,
149 td_thr_iter_f
*cb
, void *cbdata_p
,
150 td_thr_state_e state
, int ti_pri
,
151 sigset_t
*ti_sigmask_p
,
152 unsigned ti_user_flags
);
153 typedef td_err_e (td_thr_validate_ftype
)(const td_thrhandle_t
*th_p
);
154 typedef td_err_e (td_thr_tsd_ftype
)(const td_thrhandle_t
* th_p
,
155 const thread_key_t key
, void **data_pp
);
156 typedef td_err_e (td_thr_get_info_ftype
)(const td_thrhandle_t
*th_p
,
158 typedef td_err_e (td_thr_getfpregs_ftype
)(const td_thrhandle_t
*th_p
,
159 prfpregset_t
*fpregset
);
160 typedef td_err_e (td_thr_getxregsize_ftype
)(const td_thrhandle_t
*th_p
,
162 typedef td_err_e (td_thr_getxregs_ftype
)(const td_thrhandle_t
*th_p
,
163 const caddr_t xregset
);
164 typedef td_err_e (td_thr_sigsetmask_ftype
)(const td_thrhandle_t
*th_p
,
165 const sigset_t ti_sigmask
);
166 typedef td_err_e (td_thr_setprio_ftype
)(const td_thrhandle_t
*th_p
,
168 typedef td_err_e (td_thr_setsigpending_ftype
)(const td_thrhandle_t
*th_p
,
169 const uchar_t ti_pending_flag
,
170 const sigset_t ti_pending
);
171 typedef td_err_e (td_thr_setfpregs_ftype
)(const td_thrhandle_t
*th_p
,
172 const prfpregset_t
*fpregset
);
173 typedef td_err_e (td_thr_setxregs_ftype
)(const td_thrhandle_t
*th_p
,
174 const caddr_t xregset
);
175 typedef td_err_e (td_ta_map_id2thr_ftype
)(const td_thragent_t
*ta_p
,
177 td_thrhandle_t
*th_p
);
178 typedef td_err_e (td_ta_map_lwp2thr_ftype
)(const td_thragent_t
*ta_p
,
180 td_thrhandle_t
*th_p
);
181 typedef td_err_e (td_thr_getgregs_ftype
)(const td_thrhandle_t
*th_p
,
183 typedef td_err_e (td_thr_setgregs_ftype
)(const td_thrhandle_t
*th_p
,
184 const prgregset_t regset
);
186 /* Pointers to routines from libthread_db resolved by dlopen(). */
188 static td_log_ftype
*p_td_log
;
189 static td_ta_new_ftype
*p_td_ta_new
;
190 static td_ta_delete_ftype
*p_td_ta_delete
;
191 static td_init_ftype
*p_td_init
;
192 static td_ta_get_ph_ftype
*p_td_ta_get_ph
;
193 static td_ta_get_nthreads_ftype
*p_td_ta_get_nthreads
;
194 static td_ta_tsd_iter_ftype
*p_td_ta_tsd_iter
;
195 static td_ta_thr_iter_ftype
*p_td_ta_thr_iter
;
196 static td_thr_validate_ftype
*p_td_thr_validate
;
197 static td_thr_tsd_ftype
*p_td_thr_tsd
;
198 static td_thr_get_info_ftype
*p_td_thr_get_info
;
199 static td_thr_getfpregs_ftype
*p_td_thr_getfpregs
;
200 static td_thr_getxregsize_ftype
*p_td_thr_getxregsize
;
201 static td_thr_getxregs_ftype
*p_td_thr_getxregs
;
202 static td_thr_sigsetmask_ftype
*p_td_thr_sigsetmask
;
203 static td_thr_setprio_ftype
*p_td_thr_setprio
;
204 static td_thr_setsigpending_ftype
*p_td_thr_setsigpending
;
205 static td_thr_setfpregs_ftype
*p_td_thr_setfpregs
;
206 static td_thr_setxregs_ftype
*p_td_thr_setxregs
;
207 static td_ta_map_id2thr_ftype
*p_td_ta_map_id2thr
;
208 static td_ta_map_lwp2thr_ftype
*p_td_ta_map_lwp2thr
;
209 static td_thr_getgregs_ftype
*p_td_thr_getgregs
;
210 static td_thr_setgregs_ftype
*p_td_thr_setgregs
;
213 /* Return the libthread_db error string associated with ERRCODE. If
214 ERRCODE is unknown, return an appropriate message. */
217 td_err_string (td_err_e errcode
)
219 static struct string_map td_err_table
[] =
221 { TD_OK
, "generic \"call succeeded\"" },
222 { TD_ERR
, "generic error." },
223 { TD_NOTHR
, "no thread can be found to satisfy query" },
224 { TD_NOSV
, "no synch. variable can be found to satisfy query" },
225 { TD_NOLWP
, "no lwp can be found to satisfy query" },
226 { TD_BADPH
, "invalid process handle" },
227 { TD_BADTH
, "invalid thread handle" },
228 { TD_BADSH
, "invalid synchronization handle" },
229 { TD_BADTA
, "invalid thread agent" },
230 { TD_BADKEY
, "invalid key" },
231 { TD_NOMSG
, "td_thr_event_getmsg() called when there was no message" },
232 { TD_NOFPREGS
, "FPU register set not available for given thread" },
233 { TD_NOLIBTHREAD
, "application not linked with libthread" },
234 { TD_NOEVENT
, "requested event is not supported" },
235 { TD_NOCAPAB
, "capability not available" },
236 { TD_DBERR
, "Debugger service failed" },
237 { TD_NOAPLIC
, "Operation not applicable to" },
238 { TD_NOTSD
, "No thread specific data for this thread" },
239 { TD_MALLOC
, "Malloc failed" },
240 { TD_PARTIALREG
, "Only part of register set was written/read" },
241 { TD_NOXREGS
, "X register set not available for given thread" }
243 const int td_err_size
= sizeof td_err_table
/ sizeof (struct string_map
);
247 for (i
= 0; i
< td_err_size
; i
++)
248 if (td_err_table
[i
].num
== errcode
)
249 return td_err_table
[i
].str
;
251 xsnprintf (buf
, sizeof (buf
), "Unknown libthread_db error code: %d",
257 /* Return the libthread_db state string assicoated with STATECODE.
258 If STATECODE is unknown, return an appropriate message. */
261 td_state_string (td_thr_state_e statecode
)
263 static struct string_map td_thr_state_table
[] =
265 { TD_THR_ANY_STATE
, "any state" },
266 { TD_THR_UNKNOWN
, "unknown" },
267 { TD_THR_STOPPED
, "stopped" },
268 { TD_THR_RUN
, "run" },
269 { TD_THR_ACTIVE
, "active" },
270 { TD_THR_ZOMBIE
, "zombie" },
271 { TD_THR_SLEEP
, "sleep" },
272 { TD_THR_STOPPED_ASLEEP
, "stopped asleep" }
274 const int td_thr_state_table_size
=
275 sizeof td_thr_state_table
/ sizeof (struct string_map
);
279 for (i
= 0; i
< td_thr_state_table_size
; i
++)
280 if (td_thr_state_table
[i
].num
== statecode
)
281 return td_thr_state_table
[i
].str
;
283 xsnprintf (buf
, sizeof (buf
), "Unknown libthread_db state code: %d",
290 /* Convert a POSIX or Solaris thread ID into a LWP ID. If THREAD_ID
291 doesn't exist, that's an error. If it's an inactive thread, return
294 NOTE: This function probably shouldn't call error(). */
297 thread_to_lwp (ptid_t thread_id
, int default_lwp
)
303 if (thread_id
.lwp_p ())
304 return thread_id
; /* It's already an LWP ID. */
306 /* It's a thread. Convert to LWP. */
308 val
= p_td_ta_map_id2thr (main_ta
, thread_id
.tid (), &th
);
310 return ptid_t (-1); /* Thread must have terminated. */
311 else if (val
!= TD_OK
)
312 error (_("thread_to_lwp: td_ta_map_id2thr %s"), td_err_string (val
));
314 val
= p_td_thr_get_info (&th
, &ti
);
316 return ptid_t (-1); /* Thread must have terminated. */
317 else if (val
!= TD_OK
)
318 error (_("thread_to_lwp: td_thr_get_info: %s"), td_err_string (val
));
320 if (ti
.ti_state
!= TD_THR_ACTIVE
)
322 if (default_lwp
!= -1)
323 return ptid_t (default_lwp
);
324 error (_("thread_to_lwp: thread state not active: %s"),
325 td_state_string (ti
.ti_state
));
328 return ptid_t (thread_id
.pid (), ti
.ti_lid
, 0);
331 /* Convert an LWP ID into a POSIX or Solaris thread ID. If LWP_ID
332 doesn't exists, that's an error.
334 NOTE: This function probably shouldn't call error(). */
337 lwp_to_thread (ptid_t lwp
)
344 return lwp
; /* It's already a thread ID. */
346 /* It's an LWP. Convert it to a thread ID. */
348 if (!target_thread_alive (lwp
))
349 return ptid_t (-1); /* Must be a defunct LPW. */
351 val
= p_td_ta_map_lwp2thr (main_ta
, lwp
.lwp (), &th
);
353 return ptid_t (-1); /* Thread must have terminated. */
354 else if (val
!= TD_OK
)
355 error (_("lwp_to_thread: td_ta_map_lwp2thr: %s."), td_err_string (val
));
357 val
= p_td_thr_validate (&th
);
359 return lwp
; /* Unknown to libthread; just return LPW, */
360 else if (val
!= TD_OK
)
361 error (_("lwp_to_thread: td_thr_validate: %s."), td_err_string (val
));
363 val
= p_td_thr_get_info (&th
, &ti
);
365 return ptid_t (-1); /* Thread must have terminated. */
366 else if (val
!= TD_OK
)
367 error (_("lwp_to_thread: td_thr_get_info: %s."), td_err_string (val
));
369 return ptid_t (lwp
.pid (), 0 , ti
.ti_tid
);
373 /* Most target vector functions from here on actually just pass
374 through to the layer beneath, as they don't need to do anything
375 specific for threads. */
377 /* Take a program previously attached to and detaches it. The program
378 resumes execution and will no longer stop on signals, etc. We'd
379 better not have left any breakpoints in the program or it'll die
380 when it hits one. For this to work, it may be necessary for the
381 process to have been previously attached. It *might* work if the
382 program was started via the normal ptrace (PTRACE_TRACEME). */
385 sol_thread_target::detach (inferior
*inf
, int from_tty
)
387 target_ops
*beneath
= this->beneath ();
389 sol_thread_active
= 0;
390 inferior_ptid
= ptid_t (main_ph
.ptid
.pid ());
391 unpush_target (this);
392 beneath
->detach (inf
, from_tty
);
395 /* Resume execution of process PTID. If STEP is nozero, then just
396 single step it. If SIGNAL is nonzero, restart it with that signal
397 activated. We may have to convert PTID from a thread ID to an LWP
401 sol_thread_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
403 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
405 inferior_ptid
= thread_to_lwp (inferior_ptid
, main_ph
.ptid
.pid ());
406 if (inferior_ptid
.pid () == -1)
407 inferior_ptid
= procfs_first_available ();
409 if (ptid
.pid () != -1)
411 ptid_t save_ptid
= ptid
;
413 ptid
= thread_to_lwp (ptid
, -2);
414 if (ptid
.pid () == -2) /* Inactive thread. */
415 error (_("This version of Solaris can't start inactive threads."));
416 if (info_verbose
&& ptid
.pid () == -1)
417 warning (_("Specified thread %ld seems to have terminated"),
421 beneath ()->resume (ptid
, step
, signo
);
424 /* Wait for any threads to stop. We may have to convert PTID from a
425 thread ID to an LWP ID, and vice versa on the way out. */
428 sol_thread_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
434 save_ptid
= inferior_ptid
;
435 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
437 inferior_ptid
= thread_to_lwp (inferior_ptid
, main_ph
.ptid
.pid ());
438 if (inferior_ptid
.pid () == -1)
439 inferior_ptid
= procfs_first_available ();
441 if (ptid
.pid () != -1)
443 ptid_t ptid_for_warning
= ptid
;
445 ptid
= thread_to_lwp (ptid
, -2);
446 if (ptid
.pid () == -2) /* Inactive thread. */
447 error (_("This version of Solaris can't start inactive threads."));
448 if (info_verbose
&& ptid
.pid () == -1)
449 warning (_("Specified thread %ld seems to have terminated"),
450 ptid_for_warning
.tid ());
453 rtnval
= beneath ()->wait (ptid
, ourstatus
, options
);
455 if (ourstatus
->kind
!= TARGET_WAITKIND_EXITED
)
457 /* Map the LWP of interest back to the appropriate thread ID. */
458 rtnval
= lwp_to_thread (rtnval
);
459 if (rtnval
.pid () == -1)
462 /* See if we have a new thread. */
463 if (rtnval
.tid_p () && rtnval
!= save_ptid
)
465 thread_info
*thr
= find_thread_ptid (rtnval
);
466 if (thr
== NULL
|| thr
->state
== THREAD_EXITED
)
471 /* During process initialization, we may get here without the thread
472 package being initialized, since that can only happen after we've
473 found the shared libs. */
479 sol_thread_target::fetch_registers (struct regcache
*regcache
, int regnum
)
482 td_thrhandle_t thandle
;
485 prfpregset_t fpregset
;
486 gdb_gregset_t
*gregset_p
= &gregset
;
487 gdb_fpregset_t
*fpregset_p
= &fpregset
;
488 ptid_t ptid
= regcache
->ptid ();
492 /* It's an LWP; pass the request on to the layer beneath. */
493 beneath ()->fetch_registers (regcache
, regnum
);
497 /* Solaris thread: convert PTID into a td_thrhandle_t. */
498 thread
= ptid
.tid ();
500 error (_("sol_thread_fetch_registers: thread == 0"));
502 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
504 error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"),
505 td_err_string (val
));
507 /* Get the general-purpose registers. */
509 val
= p_td_thr_getgregs (&thandle
, gregset
);
510 if (val
!= TD_OK
&& val
!= TD_PARTIALREG
)
511 error (_("sol_thread_fetch_registers: td_thr_getgregs %s"),
512 td_err_string (val
));
514 /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
515 and %sp are saved (by a thread context switch). */
517 /* And, now the floating-point registers. */
519 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
520 if (val
!= TD_OK
&& val
!= TD_NOFPREGS
)
521 error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"),
522 td_err_string (val
));
524 /* Note that we must call supply_gregset and supply_fpregset *after*
525 calling the td routines because the td routines call ps_lget*
526 which affect the values stored in the registers array. */
528 supply_gregset (regcache
, (const gdb_gregset_t
*) gregset_p
);
529 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregset_p
);
533 sol_thread_target::store_registers (struct regcache
*regcache
, int regnum
)
536 td_thrhandle_t thandle
;
539 prfpregset_t fpregset
;
540 ptid_t ptid
= regcache
->ptid ();
544 /* It's an LWP; pass the request on to the layer beneath. */
545 beneath ()->store_registers (regcache
, regnum
);
549 /* Solaris thread: convert PTID into a td_thrhandle_t. */
550 thread
= ptid
.tid ();
552 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
554 error (_("sol_thread_store_registers: td_ta_map_id2thr %s"),
555 td_err_string (val
));
559 val
= p_td_thr_getgregs (&thandle
, gregset
);
561 error (_("sol_thread_store_registers: td_thr_getgregs %s"),
562 td_err_string (val
));
563 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
565 error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
566 td_err_string (val
));
569 fill_gregset (regcache
, (gdb_gregset_t
*) &gregset
, regnum
);
570 fill_fpregset (regcache
, (gdb_fpregset_t
*) &fpregset
, regnum
);
572 val
= p_td_thr_setgregs (&thandle
, gregset
);
574 error (_("sol_thread_store_registers: td_thr_setgregs %s"),
575 td_err_string (val
));
576 val
= p_td_thr_setfpregs (&thandle
, &fpregset
);
578 error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
579 td_err_string (val
));
582 /* Perform partial transfers on OBJECT. See target_read_partial and
583 target_write_partial for details of each variant. One, and only
584 one, of readbuf or writebuf must be non-NULL. */
586 enum target_xfer_status
587 sol_thread_target::xfer_partial (enum target_object object
,
588 const char *annex
, gdb_byte
*readbuf
,
589 const gdb_byte
*writebuf
,
590 ULONGEST offset
, ULONGEST len
,
591 ULONGEST
*xfered_len
)
593 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
595 if (inferior_ptid
.tid_p () || !target_thread_alive (inferior_ptid
))
597 /* It's either a thread or an LWP that isn't alive. Any live
598 LWP will do so use the first available.
600 NOTE: We don't need to call switch_to_thread; we're just
602 inferior_ptid
= procfs_first_available ();
605 return beneath ()->xfer_partial (object
, annex
, readbuf
,
606 writebuf
, offset
, len
, xfered_len
);
610 check_for_thread_db (void)
615 /* Don't attempt to use thread_db for remote targets. */
616 if (!(target_can_run () || core_bfd
))
619 /* Do nothing if we couldn't load libthread_db.so.1. */
620 if (p_td_ta_new
== NULL
)
623 if (sol_thread_active
)
624 /* Nothing to do. The thread library was already detected and the
625 target vector was already activated. */
628 /* Now, initialize libthread_db. This needs to be done after the
629 shared libraries are located because it needs information from
630 the user's thread library. */
635 warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (err
));
639 /* Now attempt to open a connection to the thread library. */
640 err
= p_td_ta_new (&main_ph
, &main_ta
);
644 /* No thread library was detected. */
648 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
650 /* The thread library was detected. Activate the sol_thread target. */
651 push_target (&sol_thread_ops
);
652 sol_thread_active
= 1;
654 main_ph
.ptid
= inferior_ptid
; /* Save for xfer_memory. */
655 ptid
= lwp_to_thread (inferior_ptid
);
656 if (ptid
.pid () != -1)
657 inferior_ptid
= ptid
;
659 target_update_thread_list ();
663 warning (_("Cannot initialize thread debugging library: %s"),
664 td_err_string (err
));
669 /* This routine is called whenever a new symbol table is read in, or
670 when all symbol tables are removed. libthread_db can only be
671 initialized when it finds the right variables in libthread.so.
672 Since it's a shared library, those variables don't show up until
673 the library gets mapped and the symbol table is read in. */
676 sol_thread_new_objfile (struct objfile
*objfile
)
679 check_for_thread_db ();
682 /* Clean up after the inferior dies. */
685 sol_thread_target::mourn_inferior ()
687 target_ops
*beneath
= this->beneath ();
689 sol_thread_active
= 0;
691 unpush_target (this);
693 beneath
->mourn_inferior ();
696 /* Return true if PTID is still active in the inferior. */
699 sol_thread_target::thread_alive (ptid_t ptid
)
703 /* It's a (user-level) thread. */
709 val
= p_td_ta_map_id2thr (main_ta
, pid
, &th
);
711 return false; /* Thread not found. */
712 val
= p_td_thr_validate (&th
);
714 return false; /* Thread not valid. */
715 return true; /* Known thread. */
719 /* It's an LPW; pass the request on to the layer below. */
720 return beneath ()->thread_alive (ptid
);
725 /* These routines implement the lower half of the thread_db interface,
726 i.e. the ps_* routines. */
728 /* The next four routines are called by libthread_db to tell us to
729 stop and stop a particular process or lwp. Since GDB ensures that
730 these are all stopped by the time we call anything in thread_db,
731 these routines need to do nothing. */
736 ps_pstop (struct ps_prochandle
*ph
)
741 /* Process continue. */
744 ps_pcontinue (struct ps_prochandle
*ph
)
752 ps_lstop (struct ps_prochandle
*ph
, lwpid_t lwpid
)
760 ps_lcontinue (struct ps_prochandle
*ph
, lwpid_t lwpid
)
765 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
768 ps_pglobal_lookup (struct ps_prochandle
*ph
, const char *ld_object_name
,
769 const char *ld_symbol_name
, psaddr_t
*ld_symbol_addr
)
771 struct bound_minimal_symbol ms
;
773 ms
= lookup_minimal_symbol (ld_symbol_name
, NULL
, NULL
);
777 *ld_symbol_addr
= BMSYMBOL_VALUE_ADDRESS (ms
);
781 /* Common routine for reading and writing memory. */
784 rw_common (int dowrite
, const struct ps_prochandle
*ph
, psaddr_t addr
,
785 gdb_byte
*buf
, int size
)
789 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
791 if (inferior_ptid
.tid_p () || !target_thread_alive (inferior_ptid
))
793 /* It's either a thread or an LWP that isn't alive. Any live
794 LWP will do so use the first available.
796 NOTE: We don't need to call switch_to_thread; we're just
798 inferior_ptid
= procfs_first_available ();
801 #if defined (__sparcv9)
802 /* For Sparc64 cross Sparc32, make sure the address has not been
803 accidentally sign-extended (or whatever) to beyond 32 bits. */
804 if (bfd_get_arch_size (exec_bfd
) == 32)
809 ret
= target_write_memory (addr
, (gdb_byte
*) buf
, size
);
811 ret
= target_read_memory (addr
, (gdb_byte
*) buf
, size
);
813 return (ret
== 0 ? PS_OK
: PS_ERR
);
816 /* Copies SIZE bytes from target process .data segment to debugger memory. */
819 ps_pdread (struct ps_prochandle
*ph
, psaddr_t addr
, void *buf
, size_t size
)
821 return rw_common (0, ph
, addr
, (gdb_byte
*) buf
, size
);
824 /* Copies SIZE bytes from debugger memory .data segment to target process. */
827 ps_pdwrite (struct ps_prochandle
*ph
, psaddr_t addr
,
828 const void *buf
, size_t size
)
830 return rw_common (1, ph
, addr
, (gdb_byte
*) buf
, size
);
833 /* Copies SIZE bytes from target process .text segment to debugger memory. */
836 ps_ptread (struct ps_prochandle
*ph
, psaddr_t addr
, void *buf
, size_t size
)
838 return rw_common (0, ph
, addr
, (gdb_byte
*) buf
, size
);
841 /* Copies SIZE bytes from debugger memory .text segment to target process. */
844 ps_ptwrite (struct ps_prochandle
*ph
, psaddr_t addr
,
845 const void *buf
, size_t size
)
847 return rw_common (1, ph
, addr
, (gdb_byte
*) buf
, size
);
850 /* Get general-purpose registers for LWP. */
853 ps_lgetregs (struct ps_prochandle
*ph
, lwpid_t lwpid
, prgregset_t gregset
)
855 ptid_t ptid
= ptid_t (inferior_ptid
.pid (), lwpid
, 0);
856 struct regcache
*regcache
857 = get_thread_arch_regcache (ptid
, target_gdbarch ());
859 target_fetch_registers (regcache
, -1);
860 fill_gregset (regcache
, (gdb_gregset_t
*) gregset
, -1);
865 /* Set general-purpose registers for LWP. */
868 ps_lsetregs (struct ps_prochandle
*ph
, lwpid_t lwpid
,
869 const prgregset_t gregset
)
871 ptid_t ptid
= ptid_t (inferior_ptid
.pid (), lwpid
, 0);
872 struct regcache
*regcache
873 = get_thread_arch_regcache (ptid
, target_gdbarch ());
875 supply_gregset (regcache
, (const gdb_gregset_t
*) gregset
);
876 target_store_registers (regcache
, -1);
881 /* Log a message (sends to gdb_stderr). */
884 ps_plog (const char *fmt
, ...)
888 va_start (args
, fmt
);
890 vfprintf_filtered (gdb_stderr
, fmt
, args
);
893 /* Get size of extra register set. Currently a noop. */
896 ps_lgetxregsize (struct ps_prochandle
*ph
, lwpid_t lwpid
, int *xregsize
)
901 /* Get extra register set. Currently a noop. */
904 ps_lgetxregs (struct ps_prochandle
*ph
, lwpid_t lwpid
, caddr_t xregset
)
909 /* Set extra register set. Currently a noop. */
912 ps_lsetxregs (struct ps_prochandle
*ph
, lwpid_t lwpid
, caddr_t xregset
)
917 /* Get floating-point registers for LWP. */
920 ps_lgetfpregs (struct ps_prochandle
*ph
, lwpid_t lwpid
,
921 prfpregset_t
*fpregset
)
923 ptid_t ptid
= ptid_t (inferior_ptid
.pid (), lwpid
, 0);
924 struct regcache
*regcache
925 = get_thread_arch_regcache (ptid
, target_gdbarch ());
927 target_fetch_registers (regcache
, -1);
928 fill_fpregset (regcache
, (gdb_fpregset_t
*) fpregset
, -1);
933 /* Set floating-point regs for LWP. */
936 ps_lsetfpregs (struct ps_prochandle
*ph
, lwpid_t lwpid
,
937 const prfpregset_t
* fpregset
)
939 ptid_t ptid
= ptid_t (inferior_ptid
.pid (), lwpid
, 0);
940 struct regcache
*regcache
941 = get_thread_arch_regcache (ptid
, target_gdbarch ());
943 supply_fpregset (regcache
, (const gdb_fpregset_t
*) fpregset
);
944 target_store_registers (regcache
, -1);
949 /* Identify process as 32-bit or 64-bit. At the moment we're using
950 BFD to do this. There might be a more Solaris-specific
951 (e.g. procfs) method, but this ought to work. */
954 ps_pdmodel (struct ps_prochandle
*ph
, int *data_model
)
957 *data_model
= PR_MODEL_UNKNOWN
;
958 else if (bfd_get_arch_size (exec_bfd
) == 32)
959 *data_model
= PR_MODEL_ILP32
;
961 *data_model
= PR_MODEL_LP64
;
966 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
968 /* Reads the local descriptor table of a LWP.
970 This function is necessary on x86-solaris only. Without it, the loading
971 of libthread_db would fail because of ps_lgetLDT being undefined. */
974 ps_lgetLDT (struct ps_prochandle
*ph
, lwpid_t lwpid
, struct ssd
*pldt
) /* ARI: editCase function */
976 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */
979 /* FIXME: can't I get the process ID from the prochandle or
982 if (inferior_ptid
.pid () <= 0 || lwpid
<= 0)
985 ret
= procfs_find_LDT_entry (ptid_t (inferior_ptid
.pid (),
989 memcpy (pldt
, ret
, sizeof (struct ssd
));
999 /* Convert PTID to printable form. */
1002 sol_thread_target::pid_to_str (ptid_t ptid
)
1004 static char buf
[100];
1010 lwp
= thread_to_lwp (ptid
, -2);
1012 if (lwp
.pid () == -1)
1013 xsnprintf (buf
, sizeof (buf
), "Thread %ld (defunct)",
1015 else if (lwp
.pid () != -2)
1016 xsnprintf (buf
, sizeof (buf
), "Thread %ld (LWP %ld)",
1017 ptid
.tid (), lwp
.lwp ());
1019 xsnprintf (buf
, sizeof (buf
), "Thread %ld ",
1022 else if (ptid
.lwp () != 0)
1023 xsnprintf (buf
, sizeof (buf
), "LWP %ld ", ptid
.lwp ());
1025 xsnprintf (buf
, sizeof (buf
), "process %d ", ptid
.pid ());
1031 /* Worker bee for update_thread_list. Callback function that gets
1032 called once per user-level thread (i.e. not for LWP's). */
1035 sol_update_thread_list_callback (const td_thrhandle_t
*th
, void *ignored
)
1040 retval
= p_td_thr_get_info (th
, &ti
);
1041 if (retval
!= TD_OK
)
1044 ptid_t ptid
= ptid_t (inferior_ptid
.pid (), 0, ti
.ti_tid
);
1045 thread_info
*thr
= find_thread_ptid (ptid
);
1046 if (thr
== NULL
|| thr
->state
== THREAD_EXITED
)
1053 sol_thread_target::update_thread_list ()
1055 /* Delete dead threads. */
1058 /* Find any new LWP's. */
1059 beneath ()->update_thread_list ();
1061 /* Then find any new user-level threads. */
1062 p_td_ta_thr_iter (main_ta
, sol_update_thread_list_callback
, (void *) 0,
1063 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1064 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1067 /* Worker bee for the "info sol-thread" command. This is a callback
1068 function that gets called once for each Solaris user-level thread
1069 (i.e. not for LWPs) in the inferior. Print anything interesting
1070 that we can think of. */
1073 info_cb (const td_thrhandle_t
*th
, void *s
)
1078 ret
= p_td_thr_get_info (th
, &ti
);
1081 printf_filtered ("%s thread #%d, lwp %d, ",
1082 ti
.ti_type
== TD_THR_SYSTEM
? "system" : "user ",
1083 ti
.ti_tid
, ti
.ti_lid
);
1084 switch (ti
.ti_state
)
1087 case TD_THR_UNKNOWN
:
1088 printf_filtered ("<unknown state>");
1090 case TD_THR_STOPPED
:
1091 printf_filtered ("(stopped)");
1094 printf_filtered ("(run) ");
1097 printf_filtered ("(active) ");
1100 printf_filtered ("(zombie) ");
1103 printf_filtered ("(asleep) ");
1105 case TD_THR_STOPPED_ASLEEP
:
1106 printf_filtered ("(stopped asleep)");
1109 /* Print thr_create start function. */
1110 if (ti
.ti_startfunc
!= 0)
1112 const struct bound_minimal_symbol msym
1113 = lookup_minimal_symbol_by_pc (ti
.ti_startfunc
);
1115 printf_filtered (" startfunc=%s",
1117 ? MSYMBOL_PRINT_NAME (msym
.minsym
)
1118 : paddress (target_gdbarch (), ti
.ti_startfunc
));
1121 /* If thread is asleep, print function that went to sleep. */
1122 if (ti
.ti_state
== TD_THR_SLEEP
)
1124 const struct bound_minimal_symbol msym
1125 = lookup_minimal_symbol_by_pc (ti
.ti_pc
);
1127 printf_filtered (" sleepfunc=%s",
1129 ? MSYMBOL_PRINT_NAME (msym
.minsym
)
1130 : paddress (target_gdbarch (), ti
.ti_pc
));
1133 printf_filtered ("\n");
1136 warning (_("info sol-thread: failed to get info for thread."));
1141 /* List some state about each Solaris user-level thread in the
1145 info_solthreads (const char *args
, int from_tty
)
1147 p_td_ta_thr_iter (main_ta
, info_cb
, (void *) args
,
1148 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1149 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1152 /* Callback routine used to find a thread based on the TID part of
1156 thread_db_find_thread_from_tid (struct thread_info
*thread
, void *data
)
1158 long *tid
= (long *) data
;
1160 if (thread
->ptid
.tid () == *tid
)
1167 sol_thread_target::get_ada_task_ptid (long lwp
, long thread
)
1169 struct thread_info
*thread_info
=
1170 iterate_over_threads (thread_db_find_thread_from_tid
, &thread
);
1172 if (thread_info
== NULL
)
1174 /* The list of threads is probably not up to date. Find any
1175 thread that is missing from the list, and try again. */
1176 update_thread_list ();
1177 thread_info
= iterate_over_threads (thread_db_find_thread_from_tid
,
1181 gdb_assert (thread_info
!= NULL
);
1183 return (thread_info
->ptid
);
1187 _initialize_sol_thread (void)
1191 dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
);
1195 #define resolve(X) \
1196 if (!(p_##X = (X ## _ftype *) dlsym (dlhandle, #X))) \
1200 resolve (td_ta_new
);
1201 resolve (td_ta_delete
);
1203 resolve (td_ta_get_ph
);
1204 resolve (td_ta_get_nthreads
);
1205 resolve (td_ta_tsd_iter
);
1206 resolve (td_ta_thr_iter
);
1207 resolve (td_thr_validate
);
1208 resolve (td_thr_tsd
);
1209 resolve (td_thr_get_info
);
1210 resolve (td_thr_getfpregs
);
1211 resolve (td_thr_getxregsize
);
1212 resolve (td_thr_getxregs
);
1213 resolve (td_thr_sigsetmask
);
1214 resolve (td_thr_setprio
);
1215 resolve (td_thr_setsigpending
);
1216 resolve (td_thr_setfpregs
);
1217 resolve (td_thr_setxregs
);
1218 resolve (td_ta_map_id2thr
);
1219 resolve (td_ta_map_lwp2thr
);
1220 resolve (td_thr_getgregs
);
1221 resolve (td_thr_setgregs
);
1223 add_cmd ("sol-threads", class_maintenance
, info_solthreads
,
1224 _("Show info on Solaris user threads."), &maintenanceinfolist
);
1226 /* Hook into new_objfile notification. */
1227 gdb::observers::new_objfile
.attach (sol_thread_new_objfile
);
1231 fprintf_unfiltered (gdb_stderr
, "\
1232 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ());