1 /* Low level interface for debugging Solaris threads for GDB, the GNU debugger.
2 Copyright 1996 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
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) to
22 provide access to the Solaris user-mode thread implementation.
24 Solaris threads are true user-mode threads, which are invoked via the thr_*
25 and pthread_* (native and Posix respectivly) interfaces. These are mostly
26 implemented in user-space, with all thread context kept in various
27 structures that live in the user's heap. These should not be confused with
28 lightweight processes (LWPs), which are implemented by the kernel, and
29 scheduled without explicit intervention by the process.
31 Just to confuse things a little, Solaris threads (both native and Posix) are
32 actually implemented using LWPs. In general, there are going to be more
33 threads than LWPs. There is no fixed correspondence between a thread and an
34 LWP. When a thread wants to run, it gets scheduled onto the first available
35 LWP and can therefore migrate from one LWP to another as time goes on. A
36 sleeping thread may not be associated with an LWP at all!
38 To make it possible to mess with threads, Sun provides a library called
39 libthread_db.so.1 (not to be confused with libthread_db.so.0, which doesn't
40 have a published interface). This interface has an upper part, which it
41 provides, and a lower part which I provide. The upper part consists of the
42 td_* routines, which allow me to find all the threads, query their state,
43 etc... The lower part consists of all of the ps_*, which are used by the
44 td_* routines to read/write memory, manipulate LWPs, lookup symbols, etc...
45 The ps_* routines actually do most of their work by calling functions in
50 /* Undefine gregset_t and fpregset_t to avoid conflict with defs in xm file. */
61 #include <proc_service.h>
62 #include <thread_db.h>
63 #include "gdbthread.h"
72 extern struct target_ops sol_thread_ops
; /* Forward declaration */
74 extern int procfs_suppress_run
;
75 extern struct target_ops procfs_ops
; /* target vector for procfs.c */
76 extern char *procfs_pid_to_str
PARAMS ((int pid
));
78 /* Note that these prototypes differ slightly from those used in procfs.c
79 for of two reasons. One, we can't use gregset_t, as that's got a whole
80 different meaning under Solaris (also, see above). Two, we can't use the
81 pointer form here as these are actually arrays of ints (for Sparc's at
82 least), and are automatically coerced into pointers to ints when used as
83 parameters. That makes it impossible to avoid a compiler warning when
84 passing pr{g fp}regset_t's from a parameter to an argument of one of
87 extern void supply_gregset
PARAMS ((const prgregset_t
));
88 extern void fill_gregset
PARAMS ((prgregset_t
, int));
89 extern void supply_fpregset
PARAMS ((const prfpregset_t
));
90 extern void fill_fpregset
PARAMS ((prfpregset_t
, int));
92 /* This struct is defined by us, but mainly used for the proc_service interface.
93 We don't have much use for it, except as a handy place to get a real pid
94 for memory accesses. */
107 static struct ps_prochandle main_ph
;
108 static td_thragent_t
*main_ta
;
109 static int sol_thread_active
= 0;
111 static struct cleanup
* save_inferior_pid
PARAMS ((void));
112 static void restore_inferior_pid
PARAMS ((int pid
));
113 static char *td_err_string
PARAMS ((td_err_e errcode
));
114 static char *td_state_string
PARAMS ((td_thr_state_e statecode
));
115 static int thread_to_lwp
PARAMS ((int thread_id
, int default_lwp
));
116 static void sol_thread_resume
PARAMS ((int pid
, int step
,
117 enum target_signal signo
));
118 static int lwp_to_thread
PARAMS ((int lwp
));
119 static int sol_thread_alive
PARAMS ((int pid
));
121 #define THREAD_FLAG 0x80000000
122 #define is_thread(ARG) (((ARG) & THREAD_FLAG) != 0)
123 #define is_lwp(ARG) (((ARG) & THREAD_FLAG) == 0)
124 #define GET_LWP(LWP_ID) (TIDGET(LWP_ID))
125 #define GET_THREAD(THREAD_ID) (((THREAD_ID) >> 16) & 0x7fff)
126 #define BUILD_LWP(LWP_ID, PID) ((LWP_ID) << 16 | (PID))
127 #define BUILD_THREAD(THREAD_ID, PID) (THREAD_FLAG | BUILD_LWP (THREAD_ID, PID))
129 /* Pointers to routines from lithread_db resolved by dlopen() */
132 (*p_td_log
) (const int on_off
);
134 (*p_td_ta_new
) (const struct ps_prochandle
*ph_p
, td_thragent_t
**ta_pp
);
136 (*p_td_ta_delete
) (td_thragent_t
*ta_p
);
140 (*p_td_ta_get_ph
) (const td_thragent_t
*ta_p
, struct ps_prochandle
**ph_pp
);
142 (*p_td_ta_get_nthreads
) (const td_thragent_t
*ta_p
, int *nthread_p
);
144 (*p_td_ta_tsd_iter
) (const td_thragent_t
*ta_p
, td_key_iter_f
*cb
, void *cbdata_p
);
146 (*p_td_ta_thr_iter
) (const td_thragent_t
*ta_p
, td_thr_iter_f
*cb
, void *cbdata_p
, td_thr_state_e state
,
147 int ti_pri
, sigset_t
*ti_sigmask_p
, unsigned ti_user_flags
);
149 (*p_td_thr_validate
) (const td_thrhandle_t
*th_p
);
151 (*p_td_thr_tsd
) (const td_thrhandle_t
*th_p
, const thread_key_t key
, void **data_pp
);
153 (*p_td_thr_get_info
) (const td_thrhandle_t
*th_p
, td_thrinfo_t
*ti_p
);
155 (*p_td_thr_getfpregs
) (const td_thrhandle_t
*th_p
, prfpregset_t
*fpregset
);
157 (*p_td_thr_getxregsize
) (const td_thrhandle_t
*th_p
, int *xregsize
);
159 (*p_td_thr_getxregs
) (const td_thrhandle_t
*th_p
, const caddr_t xregset
);
161 (*p_td_thr_sigsetmask
) (const td_thrhandle_t
*th_p
, const sigset_t ti_sigmask
);
163 (*p_td_thr_setprio
) (const td_thrhandle_t
*th_p
, const int ti_pri
);
165 (*p_td_thr_setsigpending
) (const td_thrhandle_t
*th_p
, const uchar_t ti_pending_flag
, const sigset_t ti_pending
);
167 (*p_td_thr_setfpregs
) (const td_thrhandle_t
*th_p
, const prfpregset_t
*fpregset
);
169 (*p_td_thr_setxregs
) (const td_thrhandle_t
*th_p
, const caddr_t xregset
);
171 (*p_td_ta_map_id2thr
) (const td_thragent_t
*ta_p
, thread_t tid
, td_thrhandle_t
*th_p
);
173 (*p_td_ta_map_lwp2thr
) (const td_thragent_t
*ta_p
, lwpid_t lwpid
, td_thrhandle_t
*th_p
);
175 (*p_td_thr_getgregs
) (const td_thrhandle_t
*th_p
, prgregset_t regset
);
177 (*p_td_thr_setgregs
) (const td_thrhandle_t
*th_p
, const prgregset_t regset
);
183 td_err_string - Convert a thread_db error code to a string
187 char * td_err_string (errcode)
191 Return the thread_db error string associated with errcode. If errcode
192 is unknown, then return a message.
197 td_err_string (errcode
)
200 static struct string_map
202 {TD_OK
, "generic \"call succeeded\""},
203 {TD_ERR
, "generic error."},
204 {TD_NOTHR
, "no thread can be found to satisfy query"},
205 {TD_NOSV
, "no synch. variable can be found to satisfy query"},
206 {TD_NOLWP
, "no lwp can be found to satisfy query"},
207 {TD_BADPH
, "invalid process handle"},
208 {TD_BADTH
, "invalid thread handle"},
209 {TD_BADSH
, "invalid synchronization handle"},
210 {TD_BADTA
, "invalid thread agent"},
211 {TD_BADKEY
, "invalid key"},
212 {TD_NOMSG
, "td_thr_event_getmsg() called when there was no message"},
213 {TD_NOFPREGS
, "FPU register set not available for given thread"},
214 {TD_NOLIBTHREAD
, "application not linked with libthread"},
215 {TD_NOEVENT
, "requested event is not supported"},
216 {TD_NOCAPAB
, "capability not available"},
217 {TD_DBERR
, "Debugger service failed"},
218 {TD_NOAPLIC
, "Operation not applicable to"},
219 {TD_NOTSD
, "No thread specific data for this thread"},
220 {TD_MALLOC
, "Malloc failed"},
221 {TD_PARTIALREG
, "Only part of register set was writen/read"},
222 {TD_NOXREGS
, "X register set not available for given thread"}
224 const int td_err_size
= sizeof td_err_table
/ sizeof (struct string_map
);
228 for (i
= 0; i
< td_err_size
; i
++)
229 if (td_err_table
[i
].num
== errcode
)
230 return td_err_table
[i
].str
;
232 sprintf (buf
, "Unknown thread_db error code: %d", errcode
);
241 td_state_string - Convert a thread_db state code to a string
245 char * td_state_string (statecode)
249 Return the thread_db state string associated with statecode. If
250 statecode is unknown, then return a message.
255 td_state_string (statecode
)
256 td_thr_state_e statecode
;
258 static struct string_map
259 td_thr_state_table
[] = {
260 {TD_THR_ANY_STATE
, "any state"},
261 {TD_THR_UNKNOWN
, "unknown"},
262 {TD_THR_STOPPED
, "stopped"},
264 {TD_THR_ACTIVE
, "active"},
265 {TD_THR_ZOMBIE
, "zombie"},
266 {TD_THR_SLEEP
, "sleep"},
267 {TD_THR_STOPPED_ASLEEP
, "stopped asleep"}
269 const int td_thr_state_table_size
= sizeof td_thr_state_table
/ sizeof (struct string_map
);
273 for (i
= 0; i
< td_thr_state_table_size
; i
++)
274 if (td_thr_state_table
[i
].num
== statecode
)
275 return td_thr_state_table
[i
].str
;
277 sprintf (buf
, "Unknown thread_db state code: %d", statecode
);
286 thread_to_lwp - Convert a Posix or Solaris thread id to a LWP id.
290 int thread_to_lwp (thread_id, default_lwp)
294 This function converts a Posix or Solaris thread id to a lightweight
295 process id. If thread_id is non-existent, that's an error. If it's
296 an inactive thread, then we return default_lwp.
300 This function probably shouldn't call error()...
305 thread_to_lwp (thread_id
, default_lwp
)
313 if (is_lwp (thread_id
))
314 return thread_id
; /* It's already an LWP id */
316 /* It's a thread. Convert to lwp */
318 val
= p_td_ta_map_id2thr (main_ta
, GET_THREAD (thread_id
), &th
);
320 return -1; /* thread must have terminated */
321 else if (val
!= TD_OK
)
322 error ("thread_to_lwp: td_ta_map_id2thr %s", td_err_string (val
));
324 val
= p_td_thr_get_info (&th
, &ti
);
326 return -1; /* thread must have terminated */
327 else if (val
!= TD_OK
)
328 error ("thread_to_lwp: td_thr_get_info: %s", td_err_string (val
));
330 if (ti
.ti_state
!= TD_THR_ACTIVE
)
332 if (default_lwp
!= -1)
334 error ("thread_to_lwp: thread state not active: %s",
335 td_state_string (ti
.ti_state
));
338 return BUILD_LWP (ti
.ti_lid
, PIDGET (thread_id
));
345 lwp_to_thread - Convert a LWP id to a Posix or Solaris thread id.
349 int lwp_to_thread (lwp_id)
353 This function converts a lightweight process id to a Posix or Solaris
354 thread id. If thread_id is non-existent, that's an error.
358 This function probably shouldn't call error()...
371 return lwp
; /* It's already a thread id */
373 /* It's an lwp. Convert it to a thread id. */
375 if (!sol_thread_alive (lwp
))
376 return -1; /* defunct lwp */
378 val
= p_td_ta_map_lwp2thr (main_ta
, GET_LWP (lwp
), &th
);
380 return -1; /* thread must have terminated */
381 else if (val
!= TD_OK
)
382 error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val
));
384 val
= p_td_thr_validate (&th
);
386 return lwp
; /* libthread doesn't know about it, just return lwp */
387 else if (val
!= TD_OK
)
388 error ("lwp_to_thread: td_thr_validate: %s.", td_err_string (val
));
390 val
= p_td_thr_get_info (&th
, &ti
);
392 return -1; /* thread must have terminated */
393 else if (val
!= TD_OK
)
394 error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val
));
396 return BUILD_THREAD (ti
.ti_tid
, PIDGET (lwp
));
403 save_inferior_pid - Save inferior_pid on the cleanup list
404 restore_inferior_pid - Restore inferior_pid from the cleanup list
408 struct cleanup *save_inferior_pid ()
409 void restore_inferior_pid (int pid)
413 These two functions act in unison to restore inferior_pid in
418 inferior_pid is a global variable that needs to be changed by many of
419 these routines before calling functions in procfs.c. In order to
420 guarantee that inferior_pid gets restored (in case of errors), you
421 need to call save_inferior_pid before changing it. At the end of the
422 function, you should invoke do_cleanups to restore it.
427 static struct cleanup
*
430 return make_cleanup (restore_inferior_pid
, inferior_pid
);
434 restore_inferior_pid (pid
)
441 /* Most target vector functions from here on actually just pass through to
442 procfs.c, as they don't need to do anything specific for threads. */
447 sol_thread_open (arg
, from_tty
)
451 procfs_ops
.to_open (arg
, from_tty
);
454 /* Attach to process PID, then initialize for debugging it
455 and wait for the trace-trap that results from attaching. */
458 sol_thread_attach (args
, from_tty
)
462 procfs_ops
.to_attach (args
, from_tty
);
463 /* Must get symbols from solibs before libthread_db can run! */
464 SOLIB_ADD ((char *)0, from_tty
, (struct target_ops
*)0);
465 if (sol_thread_active
)
467 printf_filtered ("sol-thread active.\n");
468 main_ph
.pid
= inferior_pid
; /* Save for xfer_memory */
469 push_target (&sol_thread_ops
);
470 inferior_pid
= lwp_to_thread (inferior_pid
);
471 if (inferior_pid
== -1)
472 inferior_pid
= main_ph
.pid
;
474 add_thread (inferior_pid
);
476 /* XXX - might want to iterate over all the threads and register them. */
479 /* Take a program previously attached to and detaches it.
480 The program resumes execution and will no longer stop
481 on signals, etc. We'd better not have left any breakpoints
482 in the program or it'll die when it hits one. For this
483 to work, it may be necessary for the process to have been
484 previously attached. It *might* work if the program was
485 started via the normal ptrace (PTRACE_TRACEME). */
488 sol_thread_detach (args
, from_tty
)
492 unpush_target (&sol_thread_ops
);
493 procfs_ops
.to_detach (args
, from_tty
);
496 /* Resume execution of process PID. If STEP is nozero, then
497 just single step it. If SIGNAL is nonzero, restart it with that
498 signal activated. We may have to convert pid from a thread-id to an LWP id
502 sol_thread_resume (pid
, step
, signo
)
505 enum target_signal signo
;
507 struct cleanup
*old_chain
;
509 old_chain
= save_inferior_pid ();
511 inferior_pid
= thread_to_lwp (inferior_pid
, main_ph
.pid
);
512 if (inferior_pid
== -1)
513 inferior_pid
= procfs_first_available ();
519 pid
= thread_to_lwp (pid
, -2);
520 if (pid
== -2) /* Inactive thread */
521 error ("This version of Solaris can't start inactive threads.");
522 if (info_verbose
&& pid
== -1)
523 warning ("Specified thread %d seems to have terminated",
524 GET_THREAD (save_pid
));
527 procfs_ops
.to_resume (pid
, step
, signo
);
529 do_cleanups (old_chain
);
532 /* Wait for any threads to stop. We may have to convert PID from a thread id
533 to a LWP id, and vice versa on the way out. */
536 sol_thread_wait (pid
, ourstatus
)
538 struct target_waitstatus
*ourstatus
;
542 struct cleanup
*old_chain
;
544 save_pid
= inferior_pid
;
545 old_chain
= save_inferior_pid ();
547 inferior_pid
= thread_to_lwp (inferior_pid
, main_ph
.pid
);
548 if (inferior_pid
== -1)
549 inferior_pid
= procfs_first_available ();
555 pid
= thread_to_lwp (pid
, -2);
556 if (pid
== -2) /* Inactive thread */
557 error ("This version of Solaris can't start inactive threads.");
558 if (info_verbose
&& pid
== -1)
559 warning ("Specified thread %d seems to have terminated",
560 GET_THREAD (save_pid
));
563 rtnval
= procfs_ops
.to_wait (pid
, ourstatus
);
565 if (ourstatus
->kind
!= TARGET_WAITKIND_EXITED
)
567 /* Map the LWP of interest back to the appropriate thread ID */
568 rtnval
= lwp_to_thread (rtnval
);
572 /* See if we have a new thread */
573 if (is_thread (rtnval
)
574 && rtnval
!= save_pid
575 && !in_thread_list (rtnval
))
577 printf_filtered ("[New %s]\n", target_pid_to_str (rtnval
));
582 /* During process initialization, we may get here without the thread package
583 being initialized, since that can only happen after we've found the shared
586 do_cleanups (old_chain
);
592 sol_thread_fetch_registers (regno
)
596 td_thrhandle_t thandle
;
599 prfpregset_t fpregset
;
605 if (!is_thread (inferior_pid
))
606 { /* LWP: pass the request on to procfs.c */
607 procfs_ops
.to_fetch_registers (regno
);
611 /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
613 thread
= GET_THREAD (inferior_pid
);
616 error ("sol_thread_fetch_registers: thread == 0");
618 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
620 error ("sol_thread_fetch_registers: td_ta_map_id2thr: %s",
621 td_err_string (val
));
623 /* Get the integer regs */
625 val
= p_td_thr_getgregs (&thandle
, gregset
);
627 && val
!= TD_PARTIALREG
)
628 error ("sol_thread_fetch_registers: td_thr_getgregs %s",
629 td_err_string (val
));
631 /* For the sparc, TD_PARTIALREG means that only i0->i7, l0->l7, pc and sp
632 are saved (by a thread context switch). */
634 /* And, now the fp regs */
636 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
638 && val
!= TD_NOFPREGS
)
639 error ("sol_thread_fetch_registers: td_thr_getfpregs %s",
640 td_err_string (val
));
642 /* Note that we must call supply_{g fp}regset *after* calling the td routines
643 because the td routines call ps_lget* which affect the values stored in the
646 supply_gregset (gregset
);
647 supply_fpregset (fpregset
);
650 /* thread_db doesn't seem to handle this right */
651 val
= td_thr_getxregsize (&thandle
, &xregsize
);
652 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
653 error ("sol_thread_fetch_registers: td_thr_getxregsize %s",
654 td_err_string (val
));
658 xregset
= alloca (xregsize
);
659 val
= td_thr_getxregs (&thandle
, xregset
);
661 error ("sol_thread_fetch_registers: td_thr_getxregs %s",
662 td_err_string (val
));
668 sol_thread_store_registers (regno
)
672 td_thrhandle_t thandle
;
675 prfpregset_t fpregset
;
681 if (!is_thread (inferior_pid
))
682 { /* LWP: pass the request on to procfs.c */
683 procfs_ops
.to_store_registers (regno
);
687 /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
689 thread
= GET_THREAD (inferior_pid
);
691 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
693 error ("sol_thread_store_registers: td_ta_map_id2thr %s",
694 td_err_string (val
));
697 { /* Not writing all the regs */
698 val
= p_td_thr_getgregs (&thandle
, regset
);
700 error ("sol_thread_store_registers: td_thr_getgregs %s",
701 td_err_string (val
));
702 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
704 error ("sol_thread_store_registers: td_thr_getfpregs %s",
705 td_err_string (val
));
708 /* thread_db doesn't seem to handle this right */
709 val
= td_thr_getxregsize (&thandle
, &xregsize
);
710 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
711 error ("sol_thread_store_registers: td_thr_getxregsize %s",
712 td_err_string (val
));
716 xregset
= alloca (xregsize
);
717 val
= td_thr_getxregs (&thandle
, xregset
);
719 error ("sol_thread_store_registers: td_thr_getxregs %s",
720 td_err_string (val
));
725 fill_gregset (regset
, regno
);
726 fill_fpregset (fpregset
, regno
);
728 val
= p_td_thr_setgregs (&thandle
, regset
);
730 error ("sol_thread_store_registers: td_thr_setgregs %s",
731 td_err_string (val
));
732 val
= p_td_thr_setfpregs (&thandle
, &fpregset
);
734 error ("sol_thread_store_registers: td_thr_setfpregs %s",
735 td_err_string (val
));
738 /* thread_db doesn't seem to handle this right */
739 val
= td_thr_getxregsize (&thandle
, &xregsize
);
740 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
741 error ("sol_thread_store_registers: td_thr_getxregsize %s",
742 td_err_string (val
));
744 /* Should probably do something about writing the xregs here, but what are
749 /* Get ready to modify the registers array. On machines which store
750 individual registers, this doesn't need to do anything. On machines
751 which store all the registers in one fell swoop, this makes sure
752 that registers contains all the registers from the program being
756 sol_thread_prepare_to_store ()
758 procfs_ops
.to_prepare_to_store ();
762 sol_thread_xfer_memory (memaddr
, myaddr
, len
, dowrite
, target
)
767 struct target_ops
*target
; /* ignored */
770 struct cleanup
*old_chain
;
772 old_chain
= save_inferior_pid ();
774 if (is_thread (inferior_pid
) || /* A thread */
775 !target_thread_alive (inferior_pid
)) /* An lwp, but not alive */
776 inferior_pid
= procfs_first_available (); /* Find any live lwp. */
777 /* Note: don't need to call switch_to_thread; we're just reading memory. */
779 retval
= procfs_ops
.to_xfer_memory (memaddr
, myaddr
, len
, dowrite
, target
);
781 do_cleanups (old_chain
);
786 /* Print status information about what we're accessing. */
789 sol_thread_files_info (ignore
)
790 struct target_ops
*ignore
;
792 procfs_ops
.to_files_info (ignore
);
796 sol_thread_kill_inferior ()
798 procfs_ops
.to_kill ();
802 sol_thread_notice_signals (pid
)
805 procfs_ops
.to_notice_signals (pid
);
808 /* Fork an inferior process, and start debugging it with /proc. */
811 sol_thread_create_inferior (exec_file
, allargs
, env
)
816 procfs_ops
.to_create_inferior (exec_file
, allargs
, env
);
818 if (sol_thread_active
&& inferior_pid
!= 0)
820 main_ph
.pid
= inferior_pid
; /* Save for xfer_memory */
822 push_target (&sol_thread_ops
);
824 inferior_pid
= lwp_to_thread (inferior_pid
);
825 if (inferior_pid
== -1)
826 inferior_pid
= main_ph
.pid
;
828 add_thread (inferior_pid
);
832 /* This routine is called whenever a new symbol table is read in, or when all
833 symbol tables are removed. libthread_db can only be initialized when it
834 finds the right variables in libthread.so. Since it's a shared library,
835 those variables don't show up until the library gets mapped and the symbol
839 sol_thread_new_objfile (objfile
)
840 struct objfile
*objfile
;
846 sol_thread_active
= 0;
851 /* don't do anything if init failed to resolve the libthread_db library */
852 if (!procfs_suppress_run
)
855 /* Now, initialize the thread debugging library. This needs to be done after
856 the shared libraries are located because it needs information from the
857 user's thread library. */
861 error ("target_new_objfile: td_init: %s", td_err_string (val
));
863 val
= p_td_ta_new (&main_ph
, &main_ta
);
864 if (val
== TD_NOLIBTHREAD
)
866 else if (val
!= TD_OK
)
867 error ("target_new_objfile: td_ta_new: %s", td_err_string (val
));
869 sol_thread_active
= 1;
872 /* Clean up after the inferior dies. */
875 sol_thread_mourn_inferior ()
877 unpush_target (&sol_thread_ops
);
878 procfs_ops
.to_mourn_inferior ();
881 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
884 sol_thread_can_run ()
886 return procfs_suppress_run
;
893 sol_thread_alive - test thread for "aliveness"
897 static bool sol_thread_alive (int pid);
901 returns true if thread still active in inferior.
906 sol_thread_alive (pid
)
909 if (is_thread (pid
)) /* non-kernel thread */
914 pid
= GET_THREAD (pid
);
915 if ((val
= p_td_ta_map_id2thr (main_ta
, pid
, &th
)) != TD_OK
)
916 return 0; /* thread not found */
917 if ((val
= p_td_thr_validate (&th
)) != TD_OK
)
918 return 0; /* thread not valid */
919 return 1; /* known thread: return true */
921 else /* kernel thread (LWP): let procfs test it */
922 return procfs_ops
.to_thread_alive (pid
);
928 procfs_ops
.to_stop ();
931 /* These routines implement the lower half of the thread_db interface. Ie: the
934 /* The next four routines are called by thread_db to tell us to stop and stop
935 a particular process or lwp. Since GDB ensures that these are all stopped
936 by the time we call anything in thread_db, these routines need to do
940 ps_pstop (const struct ps_prochandle
*ph
)
946 ps_pcontinue (const struct ps_prochandle
*ph
)
952 ps_lstop (const struct ps_prochandle
*ph
, lwpid_t lwpid
)
958 ps_lcontinue (const struct ps_prochandle
*ph
, lwpid_t lwpid
)
964 ps_pglobal_lookup (const struct ps_prochandle
*ph
, const char *ld_object_name
,
965 const char *ld_symbol_name
, paddr_t
*ld_symbol_addr
)
967 struct minimal_symbol
*ms
;
969 ms
= lookup_minimal_symbol (ld_symbol_name
, NULL
, NULL
);
974 *ld_symbol_addr
= SYMBOL_VALUE_ADDRESS (ms
);
979 /* Common routine for reading and writing memory. */
982 rw_common (int dowrite
, const struct ps_prochandle
*ph
, paddr_t addr
,
985 struct cleanup
*old_chain
;
987 old_chain
= save_inferior_pid ();
989 if (is_thread (inferior_pid
) || /* A thread */
990 !target_thread_alive (inferior_pid
)) /* An lwp, but not alive */
991 inferior_pid
= procfs_first_available (); /* Find any live lwp. */
992 /* Note: don't need to call switch_to_thread; we're just reading memory. */
998 cc
= procfs_ops
.to_xfer_memory (addr
, buf
, size
, dowrite
, &procfs_ops
);
1003 print_sys_errmsg ("rw_common (): read", errno
);
1005 print_sys_errmsg ("rw_common (): write", errno
);
1007 do_cleanups (old_chain
);
1015 do_cleanups (old_chain
);
1021 ps_pdread (const struct ps_prochandle
*ph
, paddr_t addr
, char *buf
, int size
)
1023 return rw_common (0, ph
, addr
, buf
, size
);
1027 ps_pdwrite (const struct ps_prochandle
*ph
, paddr_t addr
, char *buf
, int size
)
1029 return rw_common (1, ph
, addr
, buf
, size
);
1033 ps_ptread (const struct ps_prochandle
*ph
, paddr_t addr
, char *buf
, int size
)
1035 return rw_common (0, ph
, addr
, buf
, size
);
1039 ps_ptwrite (const struct ps_prochandle
*ph
, paddr_t addr
, char *buf
, int size
)
1041 return rw_common (1, ph
, addr
, buf
, size
);
1044 /* Get integer regs */
1047 ps_lgetregs (const struct ps_prochandle
*ph
, lwpid_t lwpid
,
1048 prgregset_t gregset
)
1050 struct cleanup
*old_chain
;
1052 old_chain
= save_inferior_pid ();
1054 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1056 procfs_ops
.to_fetch_registers (-1);
1057 fill_gregset (gregset
, -1);
1059 do_cleanups (old_chain
);
1064 /* Set integer regs */
1067 ps_lsetregs (const struct ps_prochandle
*ph
, lwpid_t lwpid
,
1068 const prgregset_t gregset
)
1070 struct cleanup
*old_chain
;
1072 old_chain
= save_inferior_pid ();
1074 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1076 supply_gregset (gregset
);
1077 procfs_ops
.to_store_registers (-1);
1079 do_cleanups (old_chain
);
1085 ps_plog (const char *fmt
, ...)
1089 va_start (args
, fmt
);
1091 vfprintf_filtered (gdb_stderr
, fmt
, args
);
1094 /* Get size of extra register set. Currently a noop. */
1097 ps_lgetxregsize (const struct ps_prochandle
*ph
, lwpid_t lwpid
, int *xregsize
)
1104 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1108 if (ioctl (lwp_fd
, PIOCGXREGSIZE
, ®size
))
1110 if (errno
== EINVAL
)
1111 return PS_NOFREGS
; /* XXX Wrong code, but this is the closest
1112 thing in proc_service.h */
1114 print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno
);
1122 /* Get extra register set. Currently a noop. */
1125 ps_lgetxregs (const struct ps_prochandle
*ph
, lwpid_t lwpid
, caddr_t xregset
)
1131 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1135 if (ioctl (lwp_fd
, PIOCGXREG
, xregset
))
1137 print_sys_errmsg ("ps_lgetxregs (): PIOCGXREG", errno
);
1145 /* Set extra register set. Currently a noop. */
1148 ps_lsetxregs (const struct ps_prochandle
*ph
, lwpid_t lwpid
, caddr_t xregset
)
1154 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1158 if (ioctl (lwp_fd
, PIOCSXREG
, xregset
))
1160 print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno
);
1168 /* Get floating-point regs. */
1171 ps_lgetfpregs (const struct ps_prochandle
*ph
, lwpid_t lwpid
,
1172 prfpregset_t
*fpregset
)
1174 struct cleanup
*old_chain
;
1176 old_chain
= save_inferior_pid ();
1178 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1180 procfs_ops
.to_fetch_registers (-1);
1181 fill_fpregset (*fpregset
, -1);
1183 do_cleanups (old_chain
);
1188 /* Set floating-point regs. */
1191 ps_lsetfpregs (const struct ps_prochandle
*ph
, lwpid_t lwpid
,
1192 const prfpregset_t
*fpregset
)
1194 struct cleanup
*old_chain
;
1196 old_chain
= save_inferior_pid ();
1198 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1200 supply_fpregset (*fpregset
);
1201 procfs_ops
.to_store_registers (-1);
1203 do_cleanups (old_chain
);
1208 /* Convert a pid to printable form. */
1211 solaris_pid_to_str (pid
)
1214 static char buf
[100];
1216 /* in case init failed to resolve the libthread_db library */
1217 if (!procfs_suppress_run
)
1218 return procfs_pid_to_str (pid
);
1220 if (is_thread (pid
))
1224 lwp
= thread_to_lwp (pid
, -2);
1227 sprintf (buf
, "Thread %d (defunct)", GET_THREAD (pid
));
1229 sprintf (buf
, "Thread %d (LWP %d)", GET_THREAD (pid
), GET_LWP (lwp
));
1231 sprintf (buf
, "Thread %d ", GET_THREAD (pid
));
1233 else if (GET_LWP (pid
) != 0)
1234 sprintf (buf
, "LWP %d ", GET_LWP (pid
));
1236 sprintf (buf
, "process %d ", PIDGET (pid
));
1242 #ifdef MAINTENANCE_CMDS
1243 /* Worker bee for info sol-thread command. This is a callback function that
1244 gets called once for each Solaris thread (ie. not kernel thread) in the
1245 inferior. Print anything interesting that we can think of. */
1249 const td_thrhandle_t
*th
;
1254 struct minimal_symbol
*msym
;
1256 if ((ret
= p_td_thr_get_info (th
, &ti
)) == TD_OK
)
1258 printf_filtered ("%s thread #%d, lwp %d, ",
1259 ti
.ti_type
== TD_THR_SYSTEM
? "system" : "user ",
1260 ti
.ti_tid
, ti
.ti_lid
);
1261 switch (ti
.ti_state
) {
1263 case TD_THR_UNKNOWN
: printf_filtered ("<unknown state>"); break;
1264 case TD_THR_STOPPED
: printf_filtered ("(stopped)"); break;
1265 case TD_THR_RUN
: printf_filtered ("(run) "); break;
1266 case TD_THR_ACTIVE
: printf_filtered ("(active) "); break;
1267 case TD_THR_ZOMBIE
: printf_filtered ("(zombie) "); break;
1268 case TD_THR_SLEEP
: printf_filtered ("(asleep) "); break;
1269 case TD_THR_STOPPED_ASLEEP
:
1270 printf_filtered ("(stopped asleep)"); break;
1272 /* Print thr_create start function: */
1273 if (ti
.ti_startfunc
!= 0)
1274 if (msym
= lookup_minimal_symbol_by_pc (ti
.ti_startfunc
))
1275 printf_filtered (" startfunc: %s\n", SYMBOL_NAME (msym
));
1277 printf_filtered (" startfunc: 0x%08x\n", ti
.ti_startfunc
);
1279 /* If thread is asleep, print function that went to sleep: */
1280 if (ti
.ti_state
== TD_THR_SLEEP
)
1281 if (msym
= lookup_minimal_symbol_by_pc (ti
.ti_pc
))
1282 printf_filtered (" - Sleep func: %s\n", SYMBOL_NAME (msym
));
1284 printf_filtered (" - Sleep func: 0x%08x\n", ti
.ti_startfunc
);
1286 /* Wrap up line, if necessary */
1287 if (ti
.ti_state
!= TD_THR_SLEEP
&& ti
.ti_startfunc
== 0)
1288 printf_filtered ("\n"); /* don't you hate counting newlines? */
1291 warning ("info sol-thread: failed to get info for thread.");
1296 /* List some state about each Solaris user thread in the inferior. */
1299 info_solthreads (args
, from_tty
)
1303 p_td_ta_thr_iter (main_ta
, info_cb
, args
,
1304 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1305 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1307 #endif /* MAINTENANCE_CMDS */
1309 struct target_ops sol_thread_ops
= {
1310 "solaris-threads", /* to_shortname */
1311 "Solaris threads and pthread.", /* to_longname */
1312 "Solaris threads and pthread support.", /* to_doc */
1313 sol_thread_open
, /* to_open */
1315 sol_thread_attach
, /* to_attach */
1316 sol_thread_detach
, /* to_detach */
1317 sol_thread_resume
, /* to_resume */
1318 sol_thread_wait
, /* to_wait */
1319 sol_thread_fetch_registers
, /* to_fetch_registers */
1320 sol_thread_store_registers
, /* to_store_registers */
1321 sol_thread_prepare_to_store
, /* to_prepare_to_store */
1322 sol_thread_xfer_memory
, /* to_xfer_memory */
1323 sol_thread_files_info
, /* to_files_info */
1324 memory_insert_breakpoint
, /* to_insert_breakpoint */
1325 memory_remove_breakpoint
, /* to_remove_breakpoint */
1326 terminal_init_inferior
, /* to_terminal_init */
1327 terminal_inferior
, /* to_terminal_inferior */
1328 terminal_ours_for_output
, /* to_terminal_ours_for_output */
1329 terminal_ours
, /* to_terminal_ours */
1330 child_terminal_info
, /* to_terminal_info */
1331 sol_thread_kill_inferior
, /* to_kill */
1333 0, /* to_lookup_symbol */
1334 sol_thread_create_inferior
, /* to_create_inferior */
1335 sol_thread_mourn_inferior
, /* to_mourn_inferior */
1336 sol_thread_can_run
, /* to_can_run */
1337 sol_thread_notice_signals
, /* to_notice_signals */
1338 sol_thread_alive
, /* to_thread_alive */
1339 sol_thread_stop
, /* to_stop */
1340 process_stratum
, /* to_stratum */
1342 1, /* to_has_all_memory */
1343 1, /* to_has_memory */
1344 1, /* to_has_stack */
1345 1, /* to_has_registers */
1346 1, /* to_has_execution */
1348 0, /* sections_end */
1349 OPS_MAGIC
/* to_magic */
1353 _initialize_sol_thread ()
1357 dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
);
1361 #define resolve(X) \
1362 if (!(p_##X = dlsym (dlhandle, #X))) \
1366 resolve (td_ta_new
);
1367 resolve (td_ta_delete
);
1369 resolve (td_ta_get_ph
);
1370 resolve (td_ta_get_nthreads
);
1371 resolve (td_ta_tsd_iter
);
1372 resolve (td_ta_thr_iter
);
1373 resolve (td_thr_validate
);
1374 resolve (td_thr_tsd
);
1375 resolve (td_thr_get_info
);
1376 resolve (td_thr_getfpregs
);
1377 resolve (td_thr_getxregsize
);
1378 resolve (td_thr_getxregs
);
1379 resolve (td_thr_sigsetmask
);
1380 resolve (td_thr_setprio
);
1381 resolve (td_thr_setsigpending
);
1382 resolve (td_thr_setfpregs
);
1383 resolve (td_thr_setxregs
);
1384 resolve (td_ta_map_id2thr
);
1385 resolve (td_ta_map_lwp2thr
);
1386 resolve (td_thr_getgregs
);
1387 resolve (td_thr_setgregs
);
1389 add_target (&sol_thread_ops
);
1391 procfs_suppress_run
= 1;
1393 #ifdef MAINTENANCE_CMDS
1394 add_cmd ("sol-threads", class_maintenance
, info_solthreads
,
1395 "Show info on Solaris user threads.\n", &maintenanceinfolist
);
1396 #endif /* MAINTENANCE_CMDS */
1402 fprintf_unfiltered (gdb_stderr
, "[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());