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"
71 extern struct target_ops sol_thread_ops
; /* Forward declaration */
73 extern int procfs_suppress_run
;
74 extern struct target_ops procfs_ops
; /* target vector for procfs.c */
75 extern char *procfs_pid_to_str
PARAMS ((int pid
));
77 /* Note that these prototypes differ slightly from those used in procfs.c
78 for of two reasons. One, we can't use gregset_t, as that's got a whole
79 different meaning under Solaris (also, see above). Two, we can't use the
80 pointer form here as these are actually arrays of ints (for Sparc's at
81 least), and are automatically coerced into pointers to ints when used as
82 parameters. That makes it impossible to avoid a compiler warning when
83 passing pr{g fp}regset_t's from a parameter to an argument of one of
86 extern void supply_gregset
PARAMS ((const prgregset_t
));
87 extern void fill_gregset
PARAMS ((prgregset_t
, int));
88 extern void supply_fpregset
PARAMS ((const prfpregset_t
));
89 extern void fill_fpregset
PARAMS ((prfpregset_t
, int));
91 /* This struct is defined by us, but mainly used for the proc_service interface.
92 We don't have much use for it, except as a handy place to get a real pid
93 for memory accesses. */
106 static struct ps_prochandle main_ph
;
107 static td_thragent_t
*main_ta
;
108 static int sol_thread_active
= 0;
110 static struct cleanup
* save_inferior_pid
PARAMS ((void));
111 static void restore_inferior_pid
PARAMS ((int pid
));
112 static char *td_err_string
PARAMS ((td_err_e errcode
));
113 static char *td_state_string
PARAMS ((td_thr_state_e statecode
));
114 static int thread_to_lwp
PARAMS ((int thread_id
, int default_lwp
));
115 static void sol_thread_resume
PARAMS ((int pid
, int step
,
116 enum target_signal signo
));
117 static int lwp_to_thread
PARAMS ((int lwp
));
118 static int sol_thread_alive
PARAMS ((int pid
));
120 #define THREAD_FLAG 0x80000000
121 #define is_thread(ARG) (((ARG) & THREAD_FLAG) != 0)
122 #define is_lwp(ARG) (((ARG) & THREAD_FLAG) == 0)
123 #define GET_LWP(LWP_ID) (TIDGET(LWP_ID))
124 #define GET_THREAD(THREAD_ID) (((THREAD_ID) >> 16) & 0x7fff)
125 #define BUILD_LWP(LWP_ID, PID) ((LWP_ID) << 16 | (PID))
126 #define BUILD_THREAD(THREAD_ID, PID) (THREAD_FLAG | BUILD_LWP (THREAD_ID, PID))
128 /* Pointers to routines from lithread_db resolved by dlopen() */
131 (*p_td_log
) (const int on_off
);
133 (*p_td_ta_new
) (const struct ps_prochandle
*ph_p
, td_thragent_t
**ta_pp
);
135 (*p_td_ta_delete
) (td_thragent_t
*ta_p
);
139 (*p_td_ta_get_ph
) (const td_thragent_t
*ta_p
, struct ps_prochandle
**ph_pp
);
141 (*p_td_ta_get_nthreads
) (const td_thragent_t
*ta_p
, int *nthread_p
);
143 (*p_td_ta_tsd_iter
) (const td_thragent_t
*ta_p
, td_key_iter_f
*cb
, void *cbdata_p
);
145 (*p_td_ta_thr_iter
) (const td_thragent_t
*ta_p
, td_thr_iter_f
*cb
, void *cbdata_p
, td_thr_state_e state
,
146 int ti_pri
, sigset_t
*ti_sigmask_p
, unsigned ti_user_flags
);
148 (*p_td_thr_validate
) (const td_thrhandle_t
*th_p
);
150 (*p_td_thr_tsd
) (const td_thrhandle_t
*th_p
, const thread_key_t key
, void **data_pp
);
152 (*p_td_thr_get_info
) (const td_thrhandle_t
*th_p
, td_thrinfo_t
*ti_p
);
154 (*p_td_thr_getfpregs
) (const td_thrhandle_t
*th_p
, prfpregset_t
*fpregset
);
156 (*p_td_thr_getxregsize
) (const td_thrhandle_t
*th_p
, int *xregsize
);
158 (*p_td_thr_getxregs
) (const td_thrhandle_t
*th_p
, const caddr_t xregset
);
160 (*p_td_thr_sigsetmask
) (const td_thrhandle_t
*th_p
, const sigset_t ti_sigmask
);
162 (*p_td_thr_setprio
) (const td_thrhandle_t
*th_p
, const int ti_pri
);
164 (*p_td_thr_setsigpending
) (const td_thrhandle_t
*th_p
, const uchar_t ti_pending_flag
, const sigset_t ti_pending
);
166 (*p_td_thr_setfpregs
) (const td_thrhandle_t
*th_p
, const prfpregset_t
*fpregset
);
168 (*p_td_thr_setxregs
) (const td_thrhandle_t
*th_p
, const caddr_t xregset
);
170 (*p_td_ta_map_id2thr
) (const td_thragent_t
*ta_p
, thread_t tid
, td_thrhandle_t
*th_p
);
172 (*p_td_ta_map_lwp2thr
) (const td_thragent_t
*ta_p
, lwpid_t lwpid
, td_thrhandle_t
*th_p
);
174 (*p_td_thr_getgregs
) (const td_thrhandle_t
*th_p
, prgregset_t regset
);
176 (*p_td_thr_setgregs
) (const td_thrhandle_t
*th_p
, const prgregset_t regset
);
182 td_err_string - Convert a thread_db error code to a string
186 char * td_err_string (errcode)
190 Return the thread_db error string associated with errcode. If errcode
191 is unknown, then return a message.
196 td_err_string (errcode
)
199 static struct string_map
201 {TD_OK
, "generic \"call succeeded\""},
202 {TD_ERR
, "generic error."},
203 {TD_NOTHR
, "no thread can be found to satisfy query"},
204 {TD_NOSV
, "no synch. variable can be found to satisfy query"},
205 {TD_NOLWP
, "no lwp can be found to satisfy query"},
206 {TD_BADPH
, "invalid process handle"},
207 {TD_BADTH
, "invalid thread handle"},
208 {TD_BADSH
, "invalid synchronization handle"},
209 {TD_BADTA
, "invalid thread agent"},
210 {TD_BADKEY
, "invalid key"},
211 {TD_NOMSG
, "td_thr_event_getmsg() called when there was no message"},
212 {TD_NOFPREGS
, "FPU register set not available for given thread"},
213 {TD_NOLIBTHREAD
, "application not linked with libthread"},
214 {TD_NOEVENT
, "requested event is not supported"},
215 {TD_NOCAPAB
, "capability not available"},
216 {TD_DBERR
, "Debugger service failed"},
217 {TD_NOAPLIC
, "Operation not applicable to"},
218 {TD_NOTSD
, "No thread specific data for this thread"},
219 {TD_MALLOC
, "Malloc failed"},
220 {TD_PARTIALREG
, "Only part of register set was writen/read"},
221 {TD_NOXREGS
, "X register set not available for given thread"}
223 const int td_err_size
= sizeof td_err_table
/ sizeof (struct string_map
);
227 for (i
= 0; i
< td_err_size
; i
++)
228 if (td_err_table
[i
].num
== errcode
)
229 return td_err_table
[i
].str
;
231 sprintf (buf
, "Unknown thread_db error code: %d", errcode
);
240 td_state_string - Convert a thread_db state code to a string
244 char * td_state_string (statecode)
248 Return the thread_db state string associated with statecode. If
249 statecode is unknown, then return a message.
254 td_state_string (statecode
)
255 td_thr_state_e statecode
;
257 static struct string_map
258 td_thr_state_table
[] = {
259 {TD_THR_ANY_STATE
, "any state"},
260 {TD_THR_UNKNOWN
, "unknown"},
261 {TD_THR_STOPPED
, "stopped"},
263 {TD_THR_ACTIVE
, "active"},
264 {TD_THR_ZOMBIE
, "zombie"},
265 {TD_THR_SLEEP
, "sleep"},
266 {TD_THR_STOPPED_ASLEEP
, "stopped asleep"}
268 const int td_thr_state_table_size
= sizeof td_thr_state_table
/ sizeof (struct string_map
);
272 for (i
= 0; i
< td_thr_state_table_size
; i
++)
273 if (td_thr_state_table
[i
].num
== statecode
)
274 return td_thr_state_table
[i
].str
;
276 sprintf (buf
, "Unknown thread_db state code: %d", statecode
);
285 thread_to_lwp - Convert a Posix or Solaris thread id to a LWP id.
289 int thread_to_lwp (thread_id, default_lwp)
293 This function converts a Posix or Solaris thread id to a lightweight
294 process id. If thread_id is non-existent, that's an error. If it's
295 an inactive thread, then we return default_lwp.
299 This function probably shouldn't call error()...
304 thread_to_lwp (thread_id
, default_lwp
)
312 if (is_lwp (thread_id
))
313 return thread_id
; /* It's already an LWP id */
315 /* It's a thread. Convert to lwp */
317 val
= p_td_ta_map_id2thr (main_ta
, GET_THREAD (thread_id
), &th
);
319 return -1; /* thread must have terminated */
320 else if (val
!= TD_OK
)
321 error ("thread_to_lwp: td_ta_map_id2thr %s", td_err_string (val
));
323 val
= p_td_thr_get_info (&th
, &ti
);
325 return -1; /* thread must have terminated */
326 else if (val
!= TD_OK
)
327 error ("thread_to_lwp: td_thr_get_info: %s", td_err_string (val
));
329 if (ti
.ti_state
!= TD_THR_ACTIVE
)
331 if (default_lwp
!= -1)
333 error ("thread_to_lwp: thread state not active: %s",
334 td_state_string (ti
.ti_state
));
337 return BUILD_LWP (ti
.ti_lid
, PIDGET (thread_id
));
344 lwp_to_thread - Convert a LWP id to a Posix or Solaris thread id.
348 int lwp_to_thread (lwp_id)
352 This function converts a lightweight process id to a Posix or Solaris
353 thread id. If thread_id is non-existent, that's an error.
357 This function probably shouldn't call error()...
370 return lwp
; /* It's already a thread id */
372 /* It's an lwp. Convert it to a thread id. */
374 if (!sol_thread_alive (lwp
))
375 return -1; /* defunct lwp */
377 val
= p_td_ta_map_lwp2thr (main_ta
, GET_LWP (lwp
), &th
);
379 return -1; /* thread must have terminated */
380 else if (val
!= TD_OK
)
381 error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val
));
383 val
= p_td_thr_validate (&th
);
385 return lwp
; /* libthread doesn't know about it, just return lwp */
386 else if (val
!= TD_OK
)
387 error ("lwp_to_thread: td_thr_validate: %s.", td_err_string (val
));
389 val
= p_td_thr_get_info (&th
, &ti
);
391 return -1; /* thread must have terminated */
392 else if (val
!= TD_OK
)
393 error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val
));
395 return BUILD_THREAD (ti
.ti_tid
, PIDGET (lwp
));
402 save_inferior_pid - Save inferior_pid on the cleanup list
403 restore_inferior_pid - Restore inferior_pid from the cleanup list
407 struct cleanup *save_inferior_pid ()
408 void restore_inferior_pid (int pid)
412 These two functions act in unison to restore inferior_pid in
417 inferior_pid is a global variable that needs to be changed by many of
418 these routines before calling functions in procfs.c. In order to
419 guarantee that inferior_pid gets restored (in case of errors), you
420 need to call save_inferior_pid before changing it. At the end of the
421 function, you should invoke do_cleanups to restore it.
426 static struct cleanup
*
429 return make_cleanup (restore_inferior_pid
, inferior_pid
);
433 restore_inferior_pid (pid
)
440 /* Most target vector functions from here on actually just pass through to
441 procfs.c, as they don't need to do anything specific for threads. */
446 sol_thread_open (arg
, from_tty
)
450 procfs_ops
.to_open (arg
, from_tty
);
453 /* Attach to process PID, then initialize for debugging it
454 and wait for the trace-trap that results from attaching. */
457 sol_thread_attach (args
, from_tty
)
461 procfs_ops
.to_attach (args
, from_tty
);
462 /* Must get symbols from solibs before libthread_db can run! */
463 SOLIB_ADD ((char *)0, from_tty
, (struct target_ops
*)0);
464 if (sol_thread_active
)
466 printf_filtered ("sol-thread active.\n");
467 main_ph
.pid
= inferior_pid
; /* Save for xfer_memory */
468 push_target (&sol_thread_ops
);
469 inferior_pid
= lwp_to_thread (inferior_pid
);
470 if (inferior_pid
== -1)
471 inferior_pid
= main_ph
.pid
;
473 add_thread (inferior_pid
);
475 /* XXX - might want to iterate over all the threads and register them. */
478 /* Take a program previously attached to and detaches it.
479 The program resumes execution and will no longer stop
480 on signals, etc. We'd better not have left any breakpoints
481 in the program or it'll die when it hits one. For this
482 to work, it may be necessary for the process to have been
483 previously attached. It *might* work if the program was
484 started via the normal ptrace (PTRACE_TRACEME). */
487 sol_thread_detach (args
, from_tty
)
491 unpush_target (&sol_thread_ops
);
492 procfs_ops
.to_detach (args
, from_tty
);
495 /* Resume execution of process PID. If STEP is nozero, then
496 just single step it. If SIGNAL is nonzero, restart it with that
497 signal activated. We may have to convert pid from a thread-id to an LWP id
501 sol_thread_resume (pid
, step
, signo
)
504 enum target_signal signo
;
506 struct cleanup
*old_chain
;
508 old_chain
= save_inferior_pid ();
510 inferior_pid
= thread_to_lwp (inferior_pid
, main_ph
.pid
);
511 if (inferior_pid
== -1)
512 inferior_pid
= procfs_first_available ();
518 pid
= thread_to_lwp (pid
, -2);
519 if (pid
== -2) /* Inactive thread */
520 error ("This version of Solaris can't start inactive threads.");
521 if (info_verbose
&& pid
== -1)
522 warning ("Specified thread %d seems to have terminated",
523 GET_THREAD (save_pid
));
526 procfs_ops
.to_resume (pid
, step
, signo
);
528 do_cleanups (old_chain
);
531 /* Wait for any threads to stop. We may have to convert PID from a thread id
532 to a LWP id, and vice versa on the way out. */
535 sol_thread_wait (pid
, ourstatus
)
537 struct target_waitstatus
*ourstatus
;
541 struct cleanup
*old_chain
;
543 save_pid
= inferior_pid
;
544 old_chain
= save_inferior_pid ();
546 inferior_pid
= thread_to_lwp (inferior_pid
, main_ph
.pid
);
547 if (inferior_pid
== -1)
548 inferior_pid
= procfs_first_available ();
554 pid
= thread_to_lwp (pid
, -2);
555 if (pid
== -2) /* Inactive thread */
556 error ("This version of Solaris can't start inactive threads.");
557 if (info_verbose
&& pid
== -1)
558 warning ("Specified thread %d seems to have terminated",
559 GET_THREAD (save_pid
));
562 rtnval
= procfs_ops
.to_wait (pid
, ourstatus
);
564 if (ourstatus
->kind
!= TARGET_WAITKIND_EXITED
)
566 /* Map the LWP of interest back to the appropriate thread ID */
567 rtnval
= lwp_to_thread (rtnval
);
571 /* See if we have a new thread */
572 if (is_thread (rtnval
)
573 && rtnval
!= save_pid
574 && !in_thread_list (rtnval
))
576 printf_filtered ("[New %s]\n", target_pid_to_str (rtnval
));
581 /* During process initialization, we may get here without the thread package
582 being initialized, since that can only happen after we've found the shared
585 do_cleanups (old_chain
);
591 sol_thread_fetch_registers (regno
)
595 td_thrhandle_t thandle
;
598 prfpregset_t fpregset
;
604 /* Convert inferior_pid into a td_thrhandle_t */
606 thread
= GET_THREAD (inferior_pid
);
609 error ("sol_thread_fetch_registers: thread == 0");
611 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
613 error ("sol_thread_fetch_registers: td_ta_map_id2thr: %s",
614 td_err_string (val
));
616 /* Get the integer regs */
618 val
= p_td_thr_getgregs (&thandle
, gregset
);
620 && val
!= TD_PARTIALREG
)
621 error ("sol_thread_fetch_registers: td_thr_getgregs %s",
622 td_err_string (val
));
624 /* For the sparc, TD_PARTIALREG means that only i0->i7, l0->l7, pc and sp
625 are saved (by a thread context switch). */
627 /* And, now the fp regs */
629 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
631 && val
!= TD_NOFPREGS
)
632 error ("sol_thread_fetch_registers: td_thr_getfpregs %s",
633 td_err_string (val
));
635 /* Note that we must call supply_{g fp}regset *after* calling the td routines
636 because the td routines call ps_lget* which affect the values stored in the
639 supply_gregset (gregset
);
640 supply_fpregset (fpregset
);
643 /* thread_db doesn't seem to handle this right */
644 val
= td_thr_getxregsize (&thandle
, &xregsize
);
645 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
646 error ("sol_thread_fetch_registers: td_thr_getxregsize %s",
647 td_err_string (val
));
651 xregset
= alloca (xregsize
);
652 val
= td_thr_getxregs (&thandle
, xregset
);
654 error ("sol_thread_fetch_registers: td_thr_getxregs %s",
655 td_err_string (val
));
661 sol_thread_store_registers (regno
)
665 td_thrhandle_t thandle
;
668 prfpregset_t fpregset
;
674 /* Convert inferior_pid into a td_thrhandle_t */
676 thread
= GET_THREAD (inferior_pid
);
678 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
680 error ("sol_thread_store_registers: td_ta_map_id2thr %s",
681 td_err_string (val
));
684 { /* Not writing all the regs */
685 val
= p_td_thr_getgregs (&thandle
, regset
);
687 error ("sol_thread_store_registers: td_thr_getgregs %s",
688 td_err_string (val
));
689 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
691 error ("sol_thread_store_registers: td_thr_getfpregs %s",
692 td_err_string (val
));
695 /* thread_db doesn't seem to handle this right */
696 val
= td_thr_getxregsize (&thandle
, &xregsize
);
697 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
698 error ("sol_thread_store_registers: td_thr_getxregsize %s",
699 td_err_string (val
));
703 xregset
= alloca (xregsize
);
704 val
= td_thr_getxregs (&thandle
, xregset
);
706 error ("sol_thread_store_registers: td_thr_getxregs %s",
707 td_err_string (val
));
712 fill_gregset (regset
, regno
);
713 fill_fpregset (fpregset
, regno
);
715 val
= p_td_thr_setgregs (&thandle
, regset
);
717 error ("sol_thread_store_registers: td_thr_setgregs %s",
718 td_err_string (val
));
719 val
= p_td_thr_setfpregs (&thandle
, &fpregset
);
721 error ("sol_thread_store_registers: td_thr_setfpregs %s",
722 td_err_string (val
));
725 /* thread_db doesn't seem to handle this right */
726 val
= td_thr_getxregsize (&thandle
, &xregsize
);
727 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
728 error ("sol_thread_store_registers: td_thr_getxregsize %s",
729 td_err_string (val
));
731 /* Should probably do something about writing the xregs here, but what are
736 /* Get ready to modify the registers array. On machines which store
737 individual registers, this doesn't need to do anything. On machines
738 which store all the registers in one fell swoop, this makes sure
739 that registers contains all the registers from the program being
743 sol_thread_prepare_to_store ()
745 procfs_ops
.to_prepare_to_store ();
749 sol_thread_xfer_memory (memaddr
, myaddr
, len
, dowrite
, target
)
754 struct target_ops
*target
; /* ignored */
757 struct cleanup
*old_chain
;
759 old_chain
= save_inferior_pid ();
761 if (is_thread (inferior_pid
))
762 inferior_pid
= main_ph
.pid
; /* It's a thread. Convert to lwp */
764 retval
= procfs_ops
.to_xfer_memory (memaddr
, myaddr
, len
, dowrite
, target
);
766 do_cleanups (old_chain
);
771 /* Print status information about what we're accessing. */
774 sol_thread_files_info (ignore
)
775 struct target_ops
*ignore
;
777 procfs_ops
.to_files_info (ignore
);
781 sol_thread_kill_inferior ()
783 procfs_ops
.to_kill ();
787 sol_thread_notice_signals (pid
)
790 procfs_ops
.to_notice_signals (pid
);
793 /* Fork an inferior process, and start debugging it with /proc. */
796 sol_thread_create_inferior (exec_file
, allargs
, env
)
801 procfs_ops
.to_create_inferior (exec_file
, allargs
, env
);
803 if (sol_thread_active
&& inferior_pid
!= 0)
805 main_ph
.pid
= inferior_pid
; /* Save for xfer_memory */
807 push_target (&sol_thread_ops
);
809 inferior_pid
= lwp_to_thread (inferior_pid
);
810 if (inferior_pid
== -1)
811 inferior_pid
= main_ph
.pid
;
813 add_thread (inferior_pid
);
817 /* This routine is called whenever a new symbol table is read in, or when all
818 symbol tables are removed. libthread_db can only be initialized when it
819 finds the right variables in libthread.so. Since it's a shared library,
820 those variables don't show up until the library gets mapped and the symbol
824 sol_thread_new_objfile (objfile
)
825 struct objfile
*objfile
;
831 sol_thread_active
= 0;
836 /* don't do anything if init failed to resolve the libthread_db library */
837 if (!procfs_suppress_run
)
840 /* Now, initialize the thread debugging library. This needs to be done after
841 the shared libraries are located because it needs information from the
842 user's thread library. */
846 error ("target_new_objfile: td_init: %s", td_err_string (val
));
848 val
= p_td_ta_new (&main_ph
, &main_ta
);
849 if (val
== TD_NOLIBTHREAD
)
851 else if (val
!= TD_OK
)
852 error ("target_new_objfile: td_ta_new: %s", td_err_string (val
));
854 sol_thread_active
= 1;
857 /* Clean up after the inferior dies. */
860 sol_thread_mourn_inferior ()
862 unpush_target (&sol_thread_ops
);
863 procfs_ops
.to_mourn_inferior ();
866 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
869 sol_thread_can_run ()
871 return procfs_suppress_run
;
878 sol_thread_alive - test thread for "aliveness"
882 static bool sol_thread_alive (int pid);
886 returns true if thread still active in inferior.
891 sol_thread_alive (pid
)
894 if (is_thread (pid
)) /* non-kernel thread */
899 pid
= GET_THREAD (pid
);
900 if ((val
= p_td_ta_map_id2thr (main_ta
, pid
, &th
)) != TD_OK
)
901 return 0; /* thread not found */
902 if ((val
= p_td_thr_validate (&th
)) != TD_OK
)
903 return 0; /* thread not valid */
904 return 1; /* known thread: return true */
906 else /* kernel thread (LWP): let procfs test it */
907 return procfs_ops
.to_thread_alive (pid
);
913 procfs_ops
.to_stop ();
916 /* These routines implement the lower half of the thread_db interface. Ie: the
919 /* The next four routines are called by thread_db to tell us to stop and stop
920 a particular process or lwp. Since GDB ensures that these are all stopped
921 by the time we call anything in thread_db, these routines need to do
925 ps_pstop (const struct ps_prochandle
*ph
)
931 ps_pcontinue (const struct ps_prochandle
*ph
)
937 ps_lstop (const struct ps_prochandle
*ph
, lwpid_t lwpid
)
943 ps_lcontinue (const struct ps_prochandle
*ph
, lwpid_t lwpid
)
949 ps_pglobal_lookup (const struct ps_prochandle
*ph
, const char *ld_object_name
,
950 const char *ld_symbol_name
, paddr_t
*ld_symbol_addr
)
952 struct minimal_symbol
*ms
;
954 ms
= lookup_minimal_symbol (ld_symbol_name
, NULL
, NULL
);
959 *ld_symbol_addr
= SYMBOL_VALUE_ADDRESS (ms
);
964 /* Common routine for reading and writing memory. */
967 rw_common (int dowrite
, const struct ps_prochandle
*ph
, paddr_t addr
,
970 struct cleanup
*old_chain
;
972 old_chain
= save_inferior_pid ();
974 if (is_thread (inferior_pid
))
975 inferior_pid
= main_ph
.pid
; /* It's a thread. Convert to lwp */
981 cc
= procfs_ops
.to_xfer_memory (addr
, buf
, size
, dowrite
, &procfs_ops
);
986 print_sys_errmsg ("rw_common (): read", errno
);
988 print_sys_errmsg ("rw_common (): write", errno
);
990 do_cleanups (old_chain
);
998 do_cleanups (old_chain
);
1004 ps_pdread (const struct ps_prochandle
*ph
, paddr_t addr
, char *buf
, int size
)
1006 return rw_common (0, ph
, addr
, buf
, size
);
1010 ps_pdwrite (const struct ps_prochandle
*ph
, paddr_t addr
, char *buf
, int size
)
1012 return rw_common (1, ph
, addr
, buf
, size
);
1016 ps_ptread (const struct ps_prochandle
*ph
, paddr_t addr
, char *buf
, int size
)
1018 return rw_common (0, ph
, addr
, buf
, size
);
1022 ps_ptwrite (const struct ps_prochandle
*ph
, paddr_t addr
, char *buf
, int size
)
1024 return rw_common (1, ph
, addr
, buf
, size
);
1027 /* Get integer regs */
1030 ps_lgetregs (const struct ps_prochandle
*ph
, lwpid_t lwpid
,
1031 prgregset_t gregset
)
1033 struct cleanup
*old_chain
;
1035 old_chain
= save_inferior_pid ();
1037 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1039 procfs_ops
.to_fetch_registers (-1);
1040 fill_gregset (gregset
, -1);
1042 do_cleanups (old_chain
);
1047 /* Set integer regs */
1050 ps_lsetregs (const struct ps_prochandle
*ph
, lwpid_t lwpid
,
1051 const prgregset_t gregset
)
1053 struct cleanup
*old_chain
;
1055 old_chain
= save_inferior_pid ();
1057 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1059 supply_gregset (gregset
);
1060 procfs_ops
.to_store_registers (-1);
1062 do_cleanups (old_chain
);
1068 ps_plog (const char *fmt
, ...)
1072 va_start (args
, fmt
);
1074 vfprintf_filtered (gdb_stderr
, fmt
, args
);
1077 /* Get size of extra register set. Currently a noop. */
1080 ps_lgetxregsize (const struct ps_prochandle
*ph
, lwpid_t lwpid
, int *xregsize
)
1087 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1091 if (ioctl (lwp_fd
, PIOCGXREGSIZE
, ®size
))
1093 if (errno
== EINVAL
)
1094 return PS_NOFREGS
; /* XXX Wrong code, but this is the closest
1095 thing in proc_service.h */
1097 print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno
);
1105 /* Get extra register set. Currently a noop. */
1108 ps_lgetxregs (const struct ps_prochandle
*ph
, lwpid_t lwpid
, caddr_t xregset
)
1114 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1118 if (ioctl (lwp_fd
, PIOCGXREG
, xregset
))
1120 print_sys_errmsg ("ps_lgetxregs (): PIOCGXREG", errno
);
1128 /* Set extra register set. Currently a noop. */
1131 ps_lsetxregs (const struct ps_prochandle
*ph
, lwpid_t lwpid
, caddr_t xregset
)
1137 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1141 if (ioctl (lwp_fd
, PIOCSXREG
, xregset
))
1143 print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno
);
1151 /* Get floating-point regs. */
1154 ps_lgetfpregs (const struct ps_prochandle
*ph
, lwpid_t lwpid
,
1155 prfpregset_t
*fpregset
)
1157 struct cleanup
*old_chain
;
1159 old_chain
= save_inferior_pid ();
1161 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1163 procfs_ops
.to_fetch_registers (-1);
1164 fill_fpregset (*fpregset
, -1);
1166 do_cleanups (old_chain
);
1171 /* Set floating-point regs. */
1174 ps_lsetfpregs (const struct ps_prochandle
*ph
, lwpid_t lwpid
,
1175 const prfpregset_t
*fpregset
)
1177 struct cleanup
*old_chain
;
1179 old_chain
= save_inferior_pid ();
1181 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1183 supply_fpregset (*fpregset
);
1184 procfs_ops
.to_store_registers (-1);
1186 do_cleanups (old_chain
);
1191 /* Convert a pid to printable form. */
1194 solaris_pid_to_str (pid
)
1197 static char buf
[100];
1199 /* in case init failed to resolve the libthread_db library */
1200 if (!procfs_suppress_run
)
1201 return procfs_pid_to_str (pid
);
1203 if (is_thread (pid
))
1207 lwp
= thread_to_lwp (pid
, -2);
1210 sprintf (buf
, "Thread %d (defunct)", GET_THREAD (pid
));
1212 sprintf (buf
, "Thread %d (LWP %d)", GET_THREAD (pid
), GET_LWP (lwp
));
1214 sprintf (buf
, "Thread %d ", GET_THREAD (pid
));
1216 else if (GET_LWP (pid
) != 0)
1217 sprintf (buf
, "LWP %d ", GET_LWP (pid
));
1219 sprintf (buf
, "process %d ", PIDGET (pid
));
1224 struct target_ops sol_thread_ops
= {
1225 "solaris-threads", /* to_shortname */
1226 "Solaris threads and pthread.", /* to_longname */
1227 "Solaris threads and pthread support.", /* to_doc */
1228 sol_thread_open
, /* to_open */
1230 sol_thread_attach
, /* to_attach */
1231 sol_thread_detach
, /* to_detach */
1232 sol_thread_resume
, /* to_resume */
1233 sol_thread_wait
, /* to_wait */
1234 sol_thread_fetch_registers
, /* to_fetch_registers */
1235 sol_thread_store_registers
, /* to_store_registers */
1236 sol_thread_prepare_to_store
, /* to_prepare_to_store */
1237 sol_thread_xfer_memory
, /* to_xfer_memory */
1238 sol_thread_files_info
, /* to_files_info */
1239 memory_insert_breakpoint
, /* to_insert_breakpoint */
1240 memory_remove_breakpoint
, /* to_remove_breakpoint */
1241 terminal_init_inferior
, /* to_terminal_init */
1242 terminal_inferior
, /* to_terminal_inferior */
1243 terminal_ours_for_output
, /* to_terminal_ours_for_output */
1244 terminal_ours
, /* to_terminal_ours */
1245 child_terminal_info
, /* to_terminal_info */
1246 sol_thread_kill_inferior
, /* to_kill */
1248 0, /* to_lookup_symbol */
1249 sol_thread_create_inferior
, /* to_create_inferior */
1250 sol_thread_mourn_inferior
, /* to_mourn_inferior */
1251 sol_thread_can_run
, /* to_can_run */
1252 sol_thread_notice_signals
, /* to_notice_signals */
1253 sol_thread_alive
, /* to_thread_alive */
1254 sol_thread_stop
, /* to_stop */
1255 process_stratum
, /* to_stratum */
1257 1, /* to_has_all_memory */
1258 1, /* to_has_memory */
1259 1, /* to_has_stack */
1260 1, /* to_has_registers */
1261 1, /* to_has_execution */
1263 0, /* sections_end */
1264 OPS_MAGIC
/* to_magic */
1268 _initialize_sol_thread ()
1272 dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
);
1276 #define resolve(X) \
1277 if (!(p_##X = dlsym (dlhandle, #X))) \
1281 resolve (td_ta_new
);
1282 resolve (td_ta_delete
);
1284 resolve (td_ta_get_ph
);
1285 resolve (td_ta_get_nthreads
);
1286 resolve (td_ta_tsd_iter
);
1287 resolve (td_ta_thr_iter
);
1288 resolve (td_thr_validate
);
1289 resolve (td_thr_tsd
);
1290 resolve (td_thr_get_info
);
1291 resolve (td_thr_getfpregs
);
1292 resolve (td_thr_getxregsize
);
1293 resolve (td_thr_getxregs
);
1294 resolve (td_thr_sigsetmask
);
1295 resolve (td_thr_setprio
);
1296 resolve (td_thr_setsigpending
);
1297 resolve (td_thr_setfpregs
);
1298 resolve (td_thr_setxregs
);
1299 resolve (td_ta_map_id2thr
);
1300 resolve (td_ta_map_lwp2thr
);
1301 resolve (td_thr_getgregs
);
1302 resolve (td_thr_setgregs
);
1304 add_target (&sol_thread_ops
);
1306 procfs_suppress_run
= 1;
1312 fprintf_unfiltered (gdb_stderr
, "[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());