1 /* Low level interface for debugging Solaris threads for GDB, the GNU debugger.
2 Copyright 1996, 1997, 1998 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 */
73 extern struct target_ops sol_core_ops
; /* Forward declaration */
75 /* place to store core_ops before we overwrite it */
76 static struct target_ops orig_core_ops
;
78 extern int procfs_suppress_run
;
79 extern struct target_ops procfs_ops
; /* target vector for procfs.c */
80 extern struct target_ops core_ops
; /* target vector for corelow.c */
81 extern char *procfs_pid_to_str
PARAMS ((int pid
));
83 /* Note that these prototypes differ slightly from those used in procfs.c
84 for of two reasons. One, we can't use gregset_t, as that's got a whole
85 different meaning under Solaris (also, see above). Two, we can't use the
86 pointer form here as these are actually arrays of ints (for Sparc's at
87 least), and are automatically coerced into pointers to ints when used as
88 parameters. That makes it impossible to avoid a compiler warning when
89 passing pr{g fp}regset_t's from a parameter to an argument of one of
92 extern void supply_gregset
PARAMS ((const prgregset_t
));
93 extern void fill_gregset
PARAMS ((prgregset_t
, int));
94 extern void supply_fpregset
PARAMS ((const prfpregset_t
*));
95 extern void fill_fpregset
PARAMS ((prfpregset_t
*, int));
97 /* This struct is defined by us, but mainly used for the proc_service interface.
98 We don't have much use for it, except as a handy place to get a real pid
99 for memory accesses. */
112 static struct ps_prochandle main_ph
;
113 static td_thragent_t
*main_ta
;
114 static int sol_thread_active
= 0;
116 static struct cleanup
* save_inferior_pid
PARAMS ((void));
117 static void restore_inferior_pid
PARAMS ((int pid
));
118 static char *td_err_string
PARAMS ((td_err_e errcode
));
119 static char *td_state_string
PARAMS ((td_thr_state_e statecode
));
120 static int thread_to_lwp
PARAMS ((int thread_id
, int default_lwp
));
121 static void sol_thread_resume
PARAMS ((int pid
, int step
,
122 enum target_signal signo
));
123 static int lwp_to_thread
PARAMS ((int lwp
));
124 static int sol_thread_alive
PARAMS ((int pid
));
125 static void sol_core_close
PARAMS ((int quitting
));
127 #define THREAD_FLAG 0x80000000
128 #define is_thread(ARG) (((ARG) & THREAD_FLAG) != 0)
129 #define is_lwp(ARG) (((ARG) & THREAD_FLAG) == 0)
130 #define GET_LWP(LWP_ID) (TIDGET(LWP_ID))
131 #define GET_THREAD(THREAD_ID) (((THREAD_ID) >> 16) & 0x7fff)
132 #define BUILD_LWP(LWP_ID, PID) ((LWP_ID) << 16 | (PID))
133 #define BUILD_THREAD(THREAD_ID, PID) (THREAD_FLAG | BUILD_LWP (THREAD_ID, PID))
135 /* Pointers to routines from lithread_db resolved by dlopen() */
138 (*p_td_log
) (const int on_off
);
140 (*p_td_ta_new
) (const struct ps_prochandle
*ph_p
, td_thragent_t
**ta_pp
);
142 (*p_td_ta_delete
) (td_thragent_t
*ta_p
);
146 (*p_td_ta_get_ph
) (const td_thragent_t
*ta_p
, struct ps_prochandle
**ph_pp
);
148 (*p_td_ta_get_nthreads
) (const td_thragent_t
*ta_p
, int *nthread_p
);
150 (*p_td_ta_tsd_iter
) (const td_thragent_t
*ta_p
, td_key_iter_f
*cb
, void *cbdata_p
);
152 (*p_td_ta_thr_iter
) (const td_thragent_t
*ta_p
, td_thr_iter_f
*cb
, void *cbdata_p
, td_thr_state_e state
,
153 int ti_pri
, sigset_t
*ti_sigmask_p
, unsigned ti_user_flags
);
155 (*p_td_thr_validate
) (const td_thrhandle_t
*th_p
);
157 (*p_td_thr_tsd
) (const td_thrhandle_t
*th_p
, const thread_key_t key
, void **data_pp
);
159 (*p_td_thr_get_info
) (const td_thrhandle_t
*th_p
, td_thrinfo_t
*ti_p
);
161 (*p_td_thr_getfpregs
) (const td_thrhandle_t
*th_p
, prfpregset_t
*fpregset
);
163 (*p_td_thr_getxregsize
) (const td_thrhandle_t
*th_p
, int *xregsize
);
165 (*p_td_thr_getxregs
) (const td_thrhandle_t
*th_p
, const caddr_t xregset
);
167 (*p_td_thr_sigsetmask
) (const td_thrhandle_t
*th_p
, const sigset_t ti_sigmask
);
169 (*p_td_thr_setprio
) (const td_thrhandle_t
*th_p
, const int ti_pri
);
171 (*p_td_thr_setsigpending
) (const td_thrhandle_t
*th_p
, const uchar_t ti_pending_flag
, const sigset_t ti_pending
);
173 (*p_td_thr_setfpregs
) (const td_thrhandle_t
*th_p
, const prfpregset_t
*fpregset
);
175 (*p_td_thr_setxregs
) (const td_thrhandle_t
*th_p
, const caddr_t xregset
);
177 (*p_td_ta_map_id2thr
) (const td_thragent_t
*ta_p
, thread_t tid
, td_thrhandle_t
*th_p
);
179 (*p_td_ta_map_lwp2thr
) (const td_thragent_t
*ta_p
, lwpid_t lwpid
, td_thrhandle_t
*th_p
);
181 (*p_td_thr_getgregs
) (const td_thrhandle_t
*th_p
, prgregset_t regset
);
183 (*p_td_thr_setgregs
) (const td_thrhandle_t
*th_p
, const prgregset_t regset
);
189 td_err_string - Convert a thread_db error code to a string
193 char * td_err_string (errcode)
197 Return the thread_db error string associated with errcode. If errcode
198 is unknown, then return a message.
203 td_err_string (errcode
)
206 static struct string_map
208 {TD_OK
, "generic \"call succeeded\""},
209 {TD_ERR
, "generic error."},
210 {TD_NOTHR
, "no thread can be found to satisfy query"},
211 {TD_NOSV
, "no synch. variable can be found to satisfy query"},
212 {TD_NOLWP
, "no lwp can be found to satisfy query"},
213 {TD_BADPH
, "invalid process handle"},
214 {TD_BADTH
, "invalid thread handle"},
215 {TD_BADSH
, "invalid synchronization handle"},
216 {TD_BADTA
, "invalid thread agent"},
217 {TD_BADKEY
, "invalid key"},
218 {TD_NOMSG
, "td_thr_event_getmsg() called when there was no message"},
219 {TD_NOFPREGS
, "FPU register set not available for given thread"},
220 {TD_NOLIBTHREAD
, "application not linked with libthread"},
221 {TD_NOEVENT
, "requested event is not supported"},
222 {TD_NOCAPAB
, "capability not available"},
223 {TD_DBERR
, "Debugger service failed"},
224 {TD_NOAPLIC
, "Operation not applicable to"},
225 {TD_NOTSD
, "No thread specific data for this thread"},
226 {TD_MALLOC
, "Malloc failed"},
227 {TD_PARTIALREG
, "Only part of register set was writen/read"},
228 {TD_NOXREGS
, "X register set not available for given thread"}
230 const int td_err_size
= sizeof td_err_table
/ sizeof (struct string_map
);
234 for (i
= 0; i
< td_err_size
; i
++)
235 if (td_err_table
[i
].num
== errcode
)
236 return td_err_table
[i
].str
;
238 sprintf (buf
, "Unknown thread_db error code: %d", errcode
);
247 td_state_string - Convert a thread_db state code to a string
251 char * td_state_string (statecode)
255 Return the thread_db state string associated with statecode. If
256 statecode is unknown, then return a message.
261 td_state_string (statecode
)
262 td_thr_state_e statecode
;
264 static struct string_map
265 td_thr_state_table
[] = {
266 {TD_THR_ANY_STATE
, "any state"},
267 {TD_THR_UNKNOWN
, "unknown"},
268 {TD_THR_STOPPED
, "stopped"},
270 {TD_THR_ACTIVE
, "active"},
271 {TD_THR_ZOMBIE
, "zombie"},
272 {TD_THR_SLEEP
, "sleep"},
273 {TD_THR_STOPPED_ASLEEP
, "stopped asleep"}
275 const int td_thr_state_table_size
= 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 sprintf (buf
, "Unknown thread_db state code: %d", statecode
);
292 thread_to_lwp - Convert a Posix or Solaris thread id to a LWP id.
296 int thread_to_lwp (thread_id, default_lwp)
300 This function converts a Posix or Solaris thread id to a lightweight
301 process id. If thread_id is non-existent, that's an error. If it's
302 an inactive thread, then we return default_lwp.
306 This function probably shouldn't call error()...
311 thread_to_lwp (thread_id
, default_lwp
)
319 if (is_lwp (thread_id
))
320 return thread_id
; /* It's already an LWP id */
322 /* It's a thread. Convert to lwp */
324 val
= p_td_ta_map_id2thr (main_ta
, GET_THREAD (thread_id
), &th
);
326 return -1; /* thread must have terminated */
327 else if (val
!= TD_OK
)
328 error ("thread_to_lwp: td_ta_map_id2thr %s", td_err_string (val
));
330 val
= p_td_thr_get_info (&th
, &ti
);
332 return -1; /* thread must have terminated */
333 else if (val
!= TD_OK
)
334 error ("thread_to_lwp: td_thr_get_info: %s", td_err_string (val
));
336 if (ti
.ti_state
!= TD_THR_ACTIVE
)
338 if (default_lwp
!= -1)
340 error ("thread_to_lwp: thread state not active: %s",
341 td_state_string (ti
.ti_state
));
344 return BUILD_LWP (ti
.ti_lid
, PIDGET (thread_id
));
351 lwp_to_thread - Convert a LWP id to a Posix or Solaris thread id.
355 int lwp_to_thread (lwp_id)
359 This function converts a lightweight process id to a Posix or Solaris
360 thread id. If thread_id is non-existent, that's an error.
364 This function probably shouldn't call error()...
377 return lwp
; /* It's already a thread id */
379 /* It's an lwp. Convert it to a thread id. */
381 if (!sol_thread_alive (lwp
))
382 return -1; /* defunct lwp */
384 val
= p_td_ta_map_lwp2thr (main_ta
, GET_LWP (lwp
), &th
);
386 return -1; /* thread must have terminated */
387 else if (val
!= TD_OK
)
388 error ("lwp_to_thread: td_ta_map_lwp2thr: %s.", td_err_string (val
));
390 val
= p_td_thr_validate (&th
);
392 return lwp
; /* libthread doesn't know about it, just return lwp */
393 else if (val
!= TD_OK
)
394 error ("lwp_to_thread: td_thr_validate: %s.", td_err_string (val
));
396 val
= p_td_thr_get_info (&th
, &ti
);
398 return -1; /* thread must have terminated */
399 else if (val
!= TD_OK
)
400 error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val
));
402 return BUILD_THREAD (ti
.ti_tid
, PIDGET (lwp
));
409 save_inferior_pid - Save inferior_pid on the cleanup list
410 restore_inferior_pid - Restore inferior_pid from the cleanup list
414 struct cleanup *save_inferior_pid ()
415 void restore_inferior_pid (int pid)
419 These two functions act in unison to restore inferior_pid in
424 inferior_pid is a global variable that needs to be changed by many of
425 these routines before calling functions in procfs.c. In order to
426 guarantee that inferior_pid gets restored (in case of errors), you
427 need to call save_inferior_pid before changing it. At the end of the
428 function, you should invoke do_cleanups to restore it.
433 static struct cleanup
*
436 return make_cleanup (restore_inferior_pid
, inferior_pid
);
440 restore_inferior_pid (pid
)
447 /* Most target vector functions from here on actually just pass through to
448 procfs.c, as they don't need to do anything specific for threads. */
453 sol_thread_open (arg
, from_tty
)
457 procfs_ops
.to_open (arg
, from_tty
);
460 /* Attach to process PID, then initialize for debugging it
461 and wait for the trace-trap that results from attaching. */
464 sol_thread_attach (args
, from_tty
)
468 procfs_ops
.to_attach (args
, from_tty
);
469 /* Must get symbols from solibs before libthread_db can run! */
470 SOLIB_ADD ((char *)0, from_tty
, (struct target_ops
*)0);
471 if (sol_thread_active
)
473 printf_filtered ("sol-thread active.\n");
474 main_ph
.pid
= inferior_pid
; /* Save for xfer_memory */
475 push_target (&sol_thread_ops
);
476 inferior_pid
= lwp_to_thread (inferior_pid
);
477 if (inferior_pid
== -1)
478 inferior_pid
= main_ph
.pid
;
480 add_thread (inferior_pid
);
482 /* XXX - might want to iterate over all the threads and register them. */
485 /* Take a program previously attached to and detaches it.
486 The program resumes execution and will no longer stop
487 on signals, etc. We'd better not have left any breakpoints
488 in the program or it'll die when it hits one. For this
489 to work, it may be necessary for the process to have been
490 previously attached. It *might* work if the program was
491 started via the normal ptrace (PTRACE_TRACEME). */
494 sol_thread_detach (args
, from_tty
)
498 unpush_target (&sol_thread_ops
);
499 procfs_ops
.to_detach (args
, from_tty
);
502 /* Resume execution of process PID. If STEP is nozero, then
503 just single step it. If SIGNAL is nonzero, restart it with that
504 signal activated. We may have to convert pid from a thread-id to an LWP id
508 sol_thread_resume (pid
, step
, signo
)
511 enum target_signal signo
;
513 struct cleanup
*old_chain
;
515 old_chain
= save_inferior_pid ();
517 inferior_pid
= thread_to_lwp (inferior_pid
, main_ph
.pid
);
518 if (inferior_pid
== -1)
519 inferior_pid
= procfs_first_available ();
525 pid
= thread_to_lwp (pid
, -2);
526 if (pid
== -2) /* Inactive thread */
527 error ("This version of Solaris can't start inactive threads.");
528 if (info_verbose
&& pid
== -1)
529 warning ("Specified thread %d seems to have terminated",
530 GET_THREAD (save_pid
));
533 procfs_ops
.to_resume (pid
, step
, signo
);
535 do_cleanups (old_chain
);
538 /* Wait for any threads to stop. We may have to convert PID from a thread id
539 to a LWP id, and vice versa on the way out. */
542 sol_thread_wait (pid
, ourstatus
)
544 struct target_waitstatus
*ourstatus
;
548 struct cleanup
*old_chain
;
550 save_pid
= inferior_pid
;
551 old_chain
= save_inferior_pid ();
553 inferior_pid
= thread_to_lwp (inferior_pid
, main_ph
.pid
);
554 if (inferior_pid
== -1)
555 inferior_pid
= procfs_first_available ();
561 pid
= thread_to_lwp (pid
, -2);
562 if (pid
== -2) /* Inactive thread */
563 error ("This version of Solaris can't start inactive threads.");
564 if (info_verbose
&& pid
== -1)
565 warning ("Specified thread %d seems to have terminated",
566 GET_THREAD (save_pid
));
569 rtnval
= procfs_ops
.to_wait (pid
, ourstatus
);
571 if (ourstatus
->kind
!= TARGET_WAITKIND_EXITED
)
573 /* Map the LWP of interest back to the appropriate thread ID */
574 rtnval
= lwp_to_thread (rtnval
);
578 /* See if we have a new thread */
579 if (is_thread (rtnval
)
580 && rtnval
!= save_pid
581 && !in_thread_list (rtnval
))
583 printf_filtered ("[New %s]\n", target_pid_to_str (rtnval
));
588 /* During process initialization, we may get here without the thread package
589 being initialized, since that can only happen after we've found the shared
592 do_cleanups (old_chain
);
598 sol_thread_fetch_registers (regno
)
602 td_thrhandle_t thandle
;
605 prfpregset_t fpregset
;
611 if (!is_thread (inferior_pid
))
612 { /* LWP: pass the request on to procfs.c */
613 if (target_has_execution
)
614 procfs_ops
.to_fetch_registers (regno
);
616 orig_core_ops
.to_fetch_registers (regno
);
620 /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
622 thread
= GET_THREAD (inferior_pid
);
625 error ("sol_thread_fetch_registers: thread == 0");
627 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
629 error ("sol_thread_fetch_registers: td_ta_map_id2thr: %s",
630 td_err_string (val
));
632 /* Get the integer regs */
634 val
= p_td_thr_getgregs (&thandle
, gregset
);
636 && val
!= TD_PARTIALREG
)
637 error ("sol_thread_fetch_registers: td_thr_getgregs %s",
638 td_err_string (val
));
640 /* For the sparc, TD_PARTIALREG means that only i0->i7, l0->l7, pc and sp
641 are saved (by a thread context switch). */
643 /* And, now the fp regs */
645 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
647 && val
!= TD_NOFPREGS
)
648 error ("sol_thread_fetch_registers: td_thr_getfpregs %s",
649 td_err_string (val
));
651 /* Note that we must call supply_{g fp}regset *after* calling the td routines
652 because the td routines call ps_lget* which affect the values stored in the
655 supply_gregset (gregset
);
656 supply_fpregset (&fpregset
);
659 /* thread_db doesn't seem to handle this right */
660 val
= td_thr_getxregsize (&thandle
, &xregsize
);
661 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
662 error ("sol_thread_fetch_registers: td_thr_getxregsize %s",
663 td_err_string (val
));
667 xregset
= alloca (xregsize
);
668 val
= td_thr_getxregs (&thandle
, xregset
);
670 error ("sol_thread_fetch_registers: td_thr_getxregs %s",
671 td_err_string (val
));
677 sol_thread_store_registers (regno
)
681 td_thrhandle_t thandle
;
684 prfpregset_t fpregset
;
690 if (!is_thread (inferior_pid
))
691 { /* LWP: pass the request on to procfs.c */
692 procfs_ops
.to_store_registers (regno
);
696 /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
698 thread
= GET_THREAD (inferior_pid
);
700 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
702 error ("sol_thread_store_registers: td_ta_map_id2thr %s",
703 td_err_string (val
));
706 { /* Not writing all the regs */
707 /* save new register value */
708 char old_value
[REGISTER_SIZE
];
709 memcpy(old_value
, & registers
[REGISTER_BYTE(regno
)], REGISTER_SIZE
);
711 val
= p_td_thr_getgregs (&thandle
, regset
);
713 error ("sol_thread_store_registers: td_thr_getgregs %s",
714 td_err_string (val
));
715 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
717 error ("sol_thread_store_registers: td_thr_getfpregs %s",
718 td_err_string (val
));
720 /* restore new register value */
721 memcpy(& registers
[REGISTER_BYTE(regno
)], old_value
, REGISTER_SIZE
);
724 /* thread_db doesn't seem to handle this right */
725 val
= td_thr_getxregsize (&thandle
, &xregsize
);
726 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
727 error ("sol_thread_store_registers: td_thr_getxregsize %s",
728 td_err_string (val
));
732 xregset
= alloca (xregsize
);
733 val
= td_thr_getxregs (&thandle
, xregset
);
735 error ("sol_thread_store_registers: td_thr_getxregs %s",
736 td_err_string (val
));
741 fill_gregset (regset
, regno
);
742 fill_fpregset (&fpregset
, regno
);
744 val
= p_td_thr_setgregs (&thandle
, regset
);
746 error ("sol_thread_store_registers: td_thr_setgregs %s",
747 td_err_string (val
));
748 val
= p_td_thr_setfpregs (&thandle
, &fpregset
);
750 error ("sol_thread_store_registers: td_thr_setfpregs %s",
751 td_err_string (val
));
754 /* thread_db doesn't seem to handle this right */
755 val
= td_thr_getxregsize (&thandle
, &xregsize
);
756 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
757 error ("sol_thread_store_registers: td_thr_getxregsize %s",
758 td_err_string (val
));
760 /* Should probably do something about writing the xregs here, but what are
765 /* Get ready to modify the registers array. On machines which store
766 individual registers, this doesn't need to do anything. On machines
767 which store all the registers in one fell swoop, this makes sure
768 that registers contains all the registers from the program being
772 sol_thread_prepare_to_store ()
774 procfs_ops
.to_prepare_to_store ();
778 sol_thread_xfer_memory (memaddr
, myaddr
, len
, dowrite
, target
)
783 struct target_ops
*target
; /* ignored */
786 struct cleanup
*old_chain
;
788 old_chain
= save_inferior_pid ();
790 if (is_thread (inferior_pid
) || /* A thread */
791 !target_thread_alive (inferior_pid
)) /* An lwp, but not alive */
792 inferior_pid
= procfs_first_available (); /* Find any live lwp. */
793 /* Note: don't need to call switch_to_thread; we're just reading memory. */
795 if (target_has_execution
)
796 retval
= procfs_ops
.to_xfer_memory (memaddr
, myaddr
, len
, dowrite
, target
);
798 retval
= orig_core_ops
.to_xfer_memory (memaddr
, myaddr
, len
,
801 do_cleanups (old_chain
);
806 /* Print status information about what we're accessing. */
809 sol_thread_files_info (ignore
)
810 struct target_ops
*ignore
;
812 procfs_ops
.to_files_info (ignore
);
816 sol_thread_kill_inferior ()
818 procfs_ops
.to_kill ();
822 sol_thread_notice_signals (pid
)
825 procfs_ops
.to_notice_signals (PIDGET (pid
));
828 /* Fork an inferior process, and start debugging it with /proc. */
831 sol_thread_create_inferior (exec_file
, allargs
, env
)
836 procfs_ops
.to_create_inferior (exec_file
, allargs
, env
);
838 if (sol_thread_active
&& inferior_pid
!= 0)
840 main_ph
.pid
= inferior_pid
; /* Save for xfer_memory */
842 push_target (&sol_thread_ops
);
844 inferior_pid
= lwp_to_thread (inferior_pid
);
845 if (inferior_pid
== -1)
846 inferior_pid
= main_ph
.pid
;
848 add_thread (inferior_pid
);
852 /* This routine is called whenever a new symbol table is read in, or when all
853 symbol tables are removed. libthread_db can only be initialized when it
854 finds the right variables in libthread.so. Since it's a shared library,
855 those variables don't show up until the library gets mapped and the symbol
859 sol_thread_new_objfile (objfile
)
860 struct objfile
*objfile
;
866 sol_thread_active
= 0;
871 /* don't do anything if init failed to resolve the libthread_db library */
872 if (!procfs_suppress_run
)
875 /* Now, initialize the thread debugging library. This needs to be done after
876 the shared libraries are located because it needs information from the
877 user's thread library. */
881 error ("target_new_objfile: td_init: %s", td_err_string (val
));
883 val
= p_td_ta_new (&main_ph
, &main_ta
);
884 if (val
== TD_NOLIBTHREAD
)
886 else if (val
!= TD_OK
)
887 error ("target_new_objfile: td_ta_new: %s", td_err_string (val
));
889 sol_thread_active
= 1;
892 /* Clean up after the inferior dies. */
895 sol_thread_mourn_inferior ()
897 unpush_target (&sol_thread_ops
);
898 procfs_ops
.to_mourn_inferior ();
901 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
904 sol_thread_can_run ()
906 return procfs_suppress_run
;
913 sol_thread_alive - test thread for "aliveness"
917 static bool sol_thread_alive (int pid);
921 returns true if thread still active in inferior.
926 sol_thread_alive (pid
)
929 if (is_thread (pid
)) /* non-kernel thread */
934 pid
= GET_THREAD (pid
);
935 if ((val
= p_td_ta_map_id2thr (main_ta
, pid
, &th
)) != TD_OK
)
936 return 0; /* thread not found */
937 if ((val
= p_td_thr_validate (&th
)) != TD_OK
)
938 return 0; /* thread not valid */
939 return 1; /* known thread: return true */
941 else /* kernel thread (LWP): let procfs test it */
943 if (target_has_execution
)
944 return procfs_ops
.to_thread_alive (pid
);
946 return orig_core_ops
.to_thread_alive (pid
);
953 procfs_ops
.to_stop ();
956 /* These routines implement the lower half of the thread_db interface. Ie: the
959 /* Various versions of <proc_service.h> have slightly
960 different function prototypes. In particular, we have
963 struct ps_prochandle * const struct ps_prochandle *
968 Which one you have depends on solaris version and what
969 patches you've applied. On the theory that there are
970 only two major variants, we have configure check the
971 prototype of ps_pdwrite (), and use that info to make
972 appropriate typedefs here. */
974 #ifdef PROC_SERVICE_IS_OLD
975 typedef const struct ps_prochandle
* gdb_ps_prochandle_t
;
976 typedef char * gdb_ps_read_buf_t
;
977 typedef char * gdb_ps_write_buf_t
;
978 typedef int gdb_ps_size_t
;
980 typedef struct ps_prochandle
* gdb_ps_prochandle_t
;
981 typedef void * gdb_ps_read_buf_t
;
982 typedef const void * gdb_ps_write_buf_t
;
983 typedef size_t gdb_ps_size_t
;
987 /* The next four routines are called by thread_db to tell us to stop and stop
988 a particular process or lwp. Since GDB ensures that these are all stopped
989 by the time we call anything in thread_db, these routines need to do
993 ps_pstop (gdb_ps_prochandle_t ph
)
999 ps_pcontinue (gdb_ps_prochandle_t ph
)
1005 ps_lstop (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
1011 ps_lcontinue (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
1017 ps_pglobal_lookup (gdb_ps_prochandle_t ph
, const char *ld_object_name
,
1018 const char *ld_symbol_name
, paddr_t
*ld_symbol_addr
)
1020 struct minimal_symbol
*ms
;
1022 ms
= lookup_minimal_symbol (ld_symbol_name
, NULL
, NULL
);
1027 *ld_symbol_addr
= SYMBOL_VALUE_ADDRESS (ms
);
1032 /* Common routine for reading and writing memory. */
1035 rw_common (int dowrite
, const struct ps_prochandle
*ph
, paddr_t addr
,
1036 char *buf
, int size
)
1038 struct cleanup
*old_chain
;
1040 old_chain
= save_inferior_pid ();
1042 if (is_thread (inferior_pid
) || /* A thread */
1043 !target_thread_alive (inferior_pid
)) /* An lwp, but not alive */
1044 inferior_pid
= procfs_first_available (); /* Find any live lwp. */
1045 /* Note: don't need to call switch_to_thread; we're just reading memory. */
1051 if (target_has_execution
)
1052 cc
= procfs_ops
.to_xfer_memory (addr
, buf
, size
, dowrite
, &procfs_ops
);
1054 cc
= orig_core_ops
.to_xfer_memory (addr
, buf
, size
, dowrite
, &core_ops
);
1059 print_sys_errmsg ("rw_common (): read", errno
);
1061 print_sys_errmsg ("rw_common (): write", errno
);
1063 do_cleanups (old_chain
);
1071 do_cleanups (old_chain
);
1077 ps_pdread (gdb_ps_prochandle_t ph
, paddr_t addr
,
1078 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
1080 return rw_common (0, ph
, addr
, buf
, size
);
1084 ps_pdwrite (gdb_ps_prochandle_t ph
, paddr_t addr
,
1085 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
1087 return rw_common (1, ph
, addr
, (char*) buf
, size
);
1091 ps_ptread (gdb_ps_prochandle_t ph
, paddr_t addr
,
1092 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
1094 return rw_common (0, ph
, addr
, buf
, size
);
1098 ps_ptwrite (gdb_ps_prochandle_t ph
, paddr_t addr
,
1099 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
1101 return rw_common (1, ph
, addr
, (char*) buf
, size
);
1104 /* Get integer regs */
1107 ps_lgetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1108 prgregset_t gregset
)
1110 struct cleanup
*old_chain
;
1112 old_chain
= save_inferior_pid ();
1114 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1116 if (target_has_execution
)
1117 procfs_ops
.to_fetch_registers (-1);
1119 orig_core_ops
.to_fetch_registers (-1);
1120 fill_gregset (gregset
, -1);
1122 do_cleanups (old_chain
);
1127 /* Set integer regs */
1130 ps_lsetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1131 const prgregset_t gregset
)
1133 struct cleanup
*old_chain
;
1135 old_chain
= save_inferior_pid ();
1137 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1139 supply_gregset (gregset
);
1140 if (target_has_execution
)
1141 procfs_ops
.to_store_registers (-1);
1143 orig_core_ops
.to_store_registers (-1);
1145 do_cleanups (old_chain
);
1151 ps_plog (const char *fmt
, ...)
1155 va_start (args
, fmt
);
1157 vfprintf_filtered (gdb_stderr
, fmt
, args
);
1160 /* Get size of extra register set. Currently a noop. */
1163 ps_lgetxregsize (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, int *xregsize
)
1170 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1174 if (ioctl (lwp_fd
, PIOCGXREGSIZE
, ®size
))
1176 if (errno
== EINVAL
)
1177 return PS_NOFREGS
; /* XXX Wrong code, but this is the closest
1178 thing in proc_service.h */
1180 print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno
);
1188 /* Get extra register set. Currently a noop. */
1191 ps_lgetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
1197 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1201 if (ioctl (lwp_fd
, PIOCGXREG
, xregset
))
1203 print_sys_errmsg ("ps_lgetxregs (): PIOCGXREG", errno
);
1211 /* Set extra register set. Currently a noop. */
1214 ps_lsetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
1220 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1224 if (ioctl (lwp_fd
, PIOCSXREG
, xregset
))
1226 print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno
);
1234 /* Get floating-point regs. */
1237 ps_lgetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1238 prfpregset_t
*fpregset
)
1240 struct cleanup
*old_chain
;
1242 old_chain
= save_inferior_pid ();
1244 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1246 if (target_has_execution
)
1247 procfs_ops
.to_fetch_registers (-1);
1249 orig_core_ops
.to_fetch_registers (-1);
1250 fill_fpregset (fpregset
, -1);
1252 do_cleanups (old_chain
);
1257 /* Set floating-point regs. */
1260 ps_lsetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1261 const prfpregset_t
*fpregset
)
1263 struct cleanup
*old_chain
;
1265 old_chain
= save_inferior_pid ();
1267 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1269 supply_fpregset (fpregset
);
1270 if (target_has_execution
)
1271 procfs_ops
.to_store_registers (-1);
1273 orig_core_ops
.to_store_registers (-1);
1275 do_cleanups (old_chain
);
1280 #ifdef TM_I386SOL2_H
1282 /* Get local descriptor table. */
1284 #include <sys/procfs.h>
1285 #include <sys/reg.h>
1286 #include <sys/sysi86.h>
1288 static int nldt_allocated
= 0;
1289 static struct ssd
*ldt_bufp
= NULL
;
1292 ps_lgetLDT (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1301 /* Get procfs file descriptor for the LWP. */
1302 lwp_fd
= procfs_get_pid_fd (BUILD_LWP (lwpid
, PIDGET (inferior_pid
)));
1306 /* Fetch registers und LDT descriptors. */
1307 if (ioctl (lwp_fd
, PIOCGREG
, &gregset
) == -1)
1310 if (ioctl (lwp_fd
, PIOCNLDT
, &nldt
) == -1)
1313 if (nldt_allocated
< nldt
)
1316 = (struct ssd
*) xrealloc (ldt_bufp
, (nldt
+ 1) * sizeof (struct ssd
));
1317 nldt_allocated
= nldt
;
1320 if (ioctl (lwp_fd
, PIOCLDT
, ldt_bufp
) == -1)
1323 /* Search LDT for the LWP via register GS. */
1324 for (i
= 0; i
< nldt
; i
++)
1326 if (ldt_bufp
[i
].sel
== (gregset
[GS
] & 0xffff))
1328 *pldt
= ldt_bufp
[i
];
1333 /* LDT not found. */
1336 #endif /* TM_I386SOL2_H */
1338 /* Convert a pid to printable form. */
1341 solaris_pid_to_str (pid
)
1344 static char buf
[100];
1346 /* in case init failed to resolve the libthread_db library */
1347 if (!procfs_suppress_run
)
1348 return procfs_pid_to_str (pid
);
1350 if (is_thread (pid
))
1354 lwp
= thread_to_lwp (pid
, -2);
1357 sprintf (buf
, "Thread %d (defunct)", GET_THREAD (pid
));
1359 sprintf (buf
, "Thread %d (LWP %d)", GET_THREAD (pid
), GET_LWP (lwp
));
1361 sprintf (buf
, "Thread %d ", GET_THREAD (pid
));
1363 else if (GET_LWP (pid
) != 0)
1364 sprintf (buf
, "LWP %d ", GET_LWP (pid
));
1366 sprintf (buf
, "process %d ", PIDGET (pid
));
1372 /* Worker bee for find_new_threads
1373 Callback function that gets called once per USER thread (i.e., not
1377 sol_find_new_threads_callback(th
, ignored
)
1378 const td_thrhandle_t
*th
;
1385 if ((retval
= p_td_thr_get_info(th
, &ti
)) != TD_OK
)
1389 pid
= BUILD_THREAD(ti
.ti_tid
, PIDGET(inferior_pid
));
1390 if (!in_thread_list(pid
))
1397 sol_find_new_threads()
1399 /* don't do anything if init failed to resolve the libthread_db library */
1400 if (!procfs_suppress_run
)
1403 if (inferior_pid
== -1)
1405 printf_filtered("No process.\n");
1408 p_td_ta_thr_iter (main_ta
, sol_find_new_threads_callback
, (void *)0,
1409 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1410 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1414 sol_core_open (filename
, from_tty
)
1418 orig_core_ops
.to_open (filename
, from_tty
);
1422 sol_core_close (quitting
)
1425 orig_core_ops
.to_close (quitting
);
1429 sol_core_detach (args
, from_tty
)
1433 unpush_target (&core_ops
);
1434 orig_core_ops
.to_detach (args
, from_tty
);
1438 sol_core_files_info (t
)
1439 struct target_ops
*t
;
1441 orig_core_ops
.to_files_info (t
);
1444 #ifdef MAINTENANCE_CMDS
1445 /* Worker bee for info sol-thread command. This is a callback function that
1446 gets called once for each Solaris thread (ie. not kernel thread) in the
1447 inferior. Print anything interesting that we can think of. */
1451 const td_thrhandle_t
*th
;
1456 struct minimal_symbol
*msym
;
1458 if ((ret
= p_td_thr_get_info (th
, &ti
)) == TD_OK
)
1460 printf_filtered ("%s thread #%d, lwp %d, ",
1461 ti
.ti_type
== TD_THR_SYSTEM
? "system" : "user ",
1462 ti
.ti_tid
, ti
.ti_lid
);
1463 switch (ti
.ti_state
) {
1465 case TD_THR_UNKNOWN
: printf_filtered ("<unknown state>"); break;
1466 case TD_THR_STOPPED
: printf_filtered ("(stopped)"); break;
1467 case TD_THR_RUN
: printf_filtered ("(run) "); break;
1468 case TD_THR_ACTIVE
: printf_filtered ("(active) "); break;
1469 case TD_THR_ZOMBIE
: printf_filtered ("(zombie) "); break;
1470 case TD_THR_SLEEP
: printf_filtered ("(asleep) "); break;
1471 case TD_THR_STOPPED_ASLEEP
:
1472 printf_filtered ("(stopped asleep)"); break;
1474 /* Print thr_create start function: */
1475 if (ti
.ti_startfunc
!= 0)
1476 if (msym
= lookup_minimal_symbol_by_pc (ti
.ti_startfunc
))
1477 printf_filtered (" startfunc: %s\n", SYMBOL_NAME (msym
));
1479 printf_filtered (" startfunc: 0x%08x\n", ti
.ti_startfunc
);
1481 /* If thread is asleep, print function that went to sleep: */
1482 if (ti
.ti_state
== TD_THR_SLEEP
)
1483 if (msym
= lookup_minimal_symbol_by_pc (ti
.ti_pc
))
1484 printf_filtered (" - Sleep func: %s\n", SYMBOL_NAME (msym
));
1486 printf_filtered (" - Sleep func: 0x%08x\n", ti
.ti_startfunc
);
1488 /* Wrap up line, if necessary */
1489 if (ti
.ti_state
!= TD_THR_SLEEP
&& ti
.ti_startfunc
== 0)
1490 printf_filtered ("\n"); /* don't you hate counting newlines? */
1493 warning ("info sol-thread: failed to get info for thread.");
1498 /* List some state about each Solaris user thread in the inferior. */
1501 info_solthreads (args
, from_tty
)
1505 p_td_ta_thr_iter (main_ta
, info_cb
, args
,
1506 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1507 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1509 #endif /* MAINTENANCE_CMDS */
1512 ignore (addr
, contents
)
1519 struct target_ops sol_thread_ops
= {
1520 "solaris-threads", /* to_shortname */
1521 "Solaris threads and pthread.", /* to_longname */
1522 "Solaris threads and pthread support.", /* to_doc */
1523 sol_thread_open
, /* to_open */
1525 sol_thread_attach
, /* to_attach */
1526 sol_thread_detach
, /* to_detach */
1527 sol_thread_resume
, /* to_resume */
1528 sol_thread_wait
, /* to_wait */
1529 sol_thread_fetch_registers
, /* to_fetch_registers */
1530 sol_thread_store_registers
, /* to_store_registers */
1531 sol_thread_prepare_to_store
, /* to_prepare_to_store */
1532 sol_thread_xfer_memory
, /* to_xfer_memory */
1533 sol_thread_files_info
, /* to_files_info */
1534 memory_insert_breakpoint
, /* to_insert_breakpoint */
1535 memory_remove_breakpoint
, /* to_remove_breakpoint */
1536 terminal_init_inferior
, /* to_terminal_init */
1537 terminal_inferior
, /* to_terminal_inferior */
1538 terminal_ours_for_output
, /* to_terminal_ours_for_output */
1539 terminal_ours
, /* to_terminal_ours */
1540 child_terminal_info
, /* to_terminal_info */
1541 sol_thread_kill_inferior
, /* to_kill */
1543 0, /* to_lookup_symbol */
1544 sol_thread_create_inferior
, /* to_create_inferior */
1545 sol_thread_mourn_inferior
, /* to_mourn_inferior */
1546 sol_thread_can_run
, /* to_can_run */
1547 sol_thread_notice_signals
, /* to_notice_signals */
1548 sol_thread_alive
, /* to_thread_alive */
1549 sol_thread_stop
, /* to_stop */
1550 process_stratum
, /* to_stratum */
1552 1, /* to_has_all_memory */
1553 1, /* to_has_memory */
1554 1, /* to_has_stack */
1555 1, /* to_has_registers */
1556 1, /* to_has_execution */
1558 0, /* sections_end */
1559 OPS_MAGIC
/* to_magic */
1562 struct target_ops sol_core_ops
= {
1563 "solaris-core", /* to_shortname */
1564 "Solaris core threads and pthread.", /* to_longname */
1565 "Solaris threads and pthread support for core files.", /* to_doc */
1566 sol_core_open
, /* to_open */
1567 sol_core_close
, /* to_close */
1568 sol_thread_attach
, /* XXX to_attach */
1569 sol_core_detach
, /* to_detach */
1572 sol_thread_fetch_registers
, /* to_fetch_registers */
1573 0, /* to_store_registers */
1574 0, /* to_prepare_to_store */
1575 sol_thread_xfer_memory
, /* XXX to_xfer_memory */
1576 sol_core_files_info
, /* to_files_info */
1577 ignore
, /* to_insert_breakpoint */
1578 ignore
, /* to_remove_breakpoint */
1579 0, /* to_terminal_init */
1580 0, /* to_terminal_inferior */
1581 0, /* to_terminal_ours_for_output */
1582 0, /* to_terminal_ours */
1583 0, /* to_terminal_info */
1586 0, /* to_lookup_symbol */
1587 sol_thread_create_inferior
, /* XXX to_create_inferior */
1588 0, /* to_mourn_inferior */
1590 0, /* to_notice_signals */
1591 0, /* to_thread_alive */
1593 core_stratum
, /* to_stratum */
1595 0, /* to_has_all_memory */
1596 1, /* to_has_memory */
1597 1, /* to_has_stack */
1598 1, /* to_has_registers */
1599 0, /* to_has_execution */
1601 0, /* sections_end */
1602 OPS_MAGIC
/* to_magic */
1605 /* we suppress the call to add_target of core_ops in corelow because
1606 if there are two targets in the stratum core_stratum, find_core_target
1607 won't know which one to return. see corelow.c for an additonal
1608 comment on coreops_suppress_target. */
1609 int coreops_suppress_target
= 1;
1612 _initialize_sol_thread ()
1616 dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
);
1620 #define resolve(X) \
1621 if (!(p_##X = dlsym (dlhandle, #X))) \
1625 resolve (td_ta_new
);
1626 resolve (td_ta_delete
);
1628 resolve (td_ta_get_ph
);
1629 resolve (td_ta_get_nthreads
);
1630 resolve (td_ta_tsd_iter
);
1631 resolve (td_ta_thr_iter
);
1632 resolve (td_thr_validate
);
1633 resolve (td_thr_tsd
);
1634 resolve (td_thr_get_info
);
1635 resolve (td_thr_getfpregs
);
1636 resolve (td_thr_getxregsize
);
1637 resolve (td_thr_getxregs
);
1638 resolve (td_thr_sigsetmask
);
1639 resolve (td_thr_setprio
);
1640 resolve (td_thr_setsigpending
);
1641 resolve (td_thr_setfpregs
);
1642 resolve (td_thr_setxregs
);
1643 resolve (td_ta_map_id2thr
);
1644 resolve (td_ta_map_lwp2thr
);
1645 resolve (td_thr_getgregs
);
1646 resolve (td_thr_setgregs
);
1648 add_target (&sol_thread_ops
);
1650 procfs_suppress_run
= 1;
1652 #ifdef MAINTENANCE_CMDS
1653 add_cmd ("sol-threads", class_maintenance
, info_solthreads
,
1654 "Show info on Solaris user threads.\n", &maintenanceinfolist
);
1655 #endif /* MAINTENANCE_CMDS */
1657 memcpy(&orig_core_ops
, &core_ops
, sizeof (struct target_ops
));
1658 memcpy(&core_ops
, &sol_core_ops
, sizeof (struct target_ops
));
1659 add_target (&core_ops
);
1665 fprintf_unfiltered (gdb_stderr
, "[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
1670 /* allow the user to debug non-threaded core files */
1671 add_target(&core_ops
);