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 /* Old versions of proc_service.h (1.3 94/10/27) have
960 prototypes that look like
961 (const struct ps_prochandle *, ...)
962 while newer versions use
963 (struct ps_prochandle *, ...)
964 and other such minor variations.
966 Someday, we might need to discover this in configure.in,
967 but the #ifdef below seems to be sufficient for now. */
970 typedef struct ps_prochandle
* gdb_ps_prochandle_t
;
971 typedef void* gdb_ps_read_buf_t
;
972 typedef const void* gdb_ps_write_buf_t
;
973 typedef size_t gdb_ps_size_t
;
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
;
981 /* The next four routines are called by thread_db to tell us to stop and stop
982 a particular process or lwp. Since GDB ensures that these are all stopped
983 by the time we call anything in thread_db, these routines need to do
987 ps_pstop (gdb_ps_prochandle_t ph
)
993 ps_pcontinue (gdb_ps_prochandle_t ph
)
999 ps_lstop (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
1005 ps_lcontinue (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
1011 ps_pglobal_lookup (gdb_ps_prochandle_t ph
, const char *ld_object_name
,
1012 const char *ld_symbol_name
, paddr_t
*ld_symbol_addr
)
1014 struct minimal_symbol
*ms
;
1016 ms
= lookup_minimal_symbol (ld_symbol_name
, NULL
, NULL
);
1021 *ld_symbol_addr
= SYMBOL_VALUE_ADDRESS (ms
);
1026 /* Common routine for reading and writing memory. */
1029 rw_common (int dowrite
, const struct ps_prochandle
*ph
, paddr_t addr
,
1030 char *buf
, int size
)
1032 struct cleanup
*old_chain
;
1034 old_chain
= save_inferior_pid ();
1036 if (is_thread (inferior_pid
) || /* A thread */
1037 !target_thread_alive (inferior_pid
)) /* An lwp, but not alive */
1038 inferior_pid
= procfs_first_available (); /* Find any live lwp. */
1039 /* Note: don't need to call switch_to_thread; we're just reading memory. */
1045 if (target_has_execution
)
1046 cc
= procfs_ops
.to_xfer_memory (addr
, buf
, size
, dowrite
, &procfs_ops
);
1048 cc
= orig_core_ops
.to_xfer_memory (addr
, buf
, size
, dowrite
, &core_ops
);
1053 print_sys_errmsg ("rw_common (): read", errno
);
1055 print_sys_errmsg ("rw_common (): write", errno
);
1057 do_cleanups (old_chain
);
1065 do_cleanups (old_chain
);
1071 ps_pdread (gdb_ps_prochandle_t ph
, paddr_t addr
,
1072 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
1074 return rw_common (0, ph
, addr
, buf
, size
);
1078 ps_pdwrite (gdb_ps_prochandle_t ph
, paddr_t addr
,
1079 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
1081 return rw_common (1, ph
, addr
, (char*) buf
, size
);
1085 ps_ptread (gdb_ps_prochandle_t ph
, paddr_t addr
,
1086 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
1088 return rw_common (0, ph
, addr
, buf
, size
);
1092 ps_ptwrite (gdb_ps_prochandle_t ph
, paddr_t addr
,
1093 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
1095 return rw_common (1, ph
, addr
, (char*) buf
, size
);
1098 /* Get integer regs */
1101 ps_lgetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1102 prgregset_t gregset
)
1104 struct cleanup
*old_chain
;
1106 old_chain
= save_inferior_pid ();
1108 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1110 if (target_has_execution
)
1111 procfs_ops
.to_fetch_registers (-1);
1113 orig_core_ops
.to_fetch_registers (-1);
1114 fill_gregset (gregset
, -1);
1116 do_cleanups (old_chain
);
1121 /* Set integer regs */
1124 ps_lsetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1125 const prgregset_t gregset
)
1127 struct cleanup
*old_chain
;
1129 old_chain
= save_inferior_pid ();
1131 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1133 supply_gregset (gregset
);
1134 if (target_has_execution
)
1135 procfs_ops
.to_store_registers (-1);
1137 orig_core_ops
.to_store_registers (-1);
1139 do_cleanups (old_chain
);
1145 ps_plog (const char *fmt
, ...)
1149 va_start (args
, fmt
);
1151 vfprintf_filtered (gdb_stderr
, fmt
, args
);
1154 /* Get size of extra register set. Currently a noop. */
1157 ps_lgetxregsize (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, int *xregsize
)
1164 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1168 if (ioctl (lwp_fd
, PIOCGXREGSIZE
, ®size
))
1170 if (errno
== EINVAL
)
1171 return PS_NOFREGS
; /* XXX Wrong code, but this is the closest
1172 thing in proc_service.h */
1174 print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno
);
1182 /* Get extra register set. Currently a noop. */
1185 ps_lgetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
1191 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1195 if (ioctl (lwp_fd
, PIOCGXREG
, xregset
))
1197 print_sys_errmsg ("ps_lgetxregs (): PIOCGXREG", errno
);
1205 /* Set extra register set. Currently a noop. */
1208 ps_lsetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
1214 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1218 if (ioctl (lwp_fd
, PIOCSXREG
, xregset
))
1220 print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno
);
1228 /* Get floating-point regs. */
1231 ps_lgetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1232 prfpregset_t
*fpregset
)
1234 struct cleanup
*old_chain
;
1236 old_chain
= save_inferior_pid ();
1238 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1240 if (target_has_execution
)
1241 procfs_ops
.to_fetch_registers (-1);
1243 orig_core_ops
.to_fetch_registers (-1);
1244 fill_fpregset (fpregset
, -1);
1246 do_cleanups (old_chain
);
1251 /* Set floating-point regs. */
1254 ps_lsetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1255 const prfpregset_t
*fpregset
)
1257 struct cleanup
*old_chain
;
1259 old_chain
= save_inferior_pid ();
1261 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1263 supply_fpregset (fpregset
);
1264 if (target_has_execution
)
1265 procfs_ops
.to_store_registers (-1);
1267 orig_core_ops
.to_store_registers (-1);
1269 do_cleanups (old_chain
);
1274 #ifdef TM_I386SOL2_H
1276 /* Get local descriptor table. */
1278 #include <sys/procfs.h>
1279 #include <sys/reg.h>
1280 #include <sys/sysi86.h>
1282 static int nldt_allocated
= 0;
1283 static struct ssd
*ldt_bufp
= NULL
;
1286 ps_lgetLDT (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1295 /* Get procfs file descriptor for the LWP. */
1296 lwp_fd
= procfs_get_pid_fd (BUILD_LWP (lwpid
, PIDGET (inferior_pid
)));
1300 /* Fetch registers und LDT descriptors. */
1301 if (ioctl (lwp_fd
, PIOCGREG
, &gregset
) == -1)
1304 if (ioctl (lwp_fd
, PIOCNLDT
, &nldt
) == -1)
1307 if (nldt_allocated
< nldt
)
1310 = (struct ssd
*) xrealloc (ldt_bufp
, (nldt
+ 1) * sizeof (struct ssd
));
1311 nldt_allocated
= nldt
;
1314 if (ioctl (lwp_fd
, PIOCLDT
, ldt_bufp
) == -1)
1317 /* Search LDT for the LWP via register GS. */
1318 for (i
= 0; i
< nldt
; i
++)
1320 if (ldt_bufp
[i
].sel
== (gregset
[GS
] & 0xffff))
1322 *pldt
= ldt_bufp
[i
];
1327 /* LDT not found. */
1330 #endif /* TM_I386SOL2_H */
1332 /* Convert a pid to printable form. */
1335 solaris_pid_to_str (pid
)
1338 static char buf
[100];
1340 /* in case init failed to resolve the libthread_db library */
1341 if (!procfs_suppress_run
)
1342 return procfs_pid_to_str (pid
);
1344 if (is_thread (pid
))
1348 lwp
= thread_to_lwp (pid
, -2);
1351 sprintf (buf
, "Thread %d (defunct)", GET_THREAD (pid
));
1353 sprintf (buf
, "Thread %d (LWP %d)", GET_THREAD (pid
), GET_LWP (lwp
));
1355 sprintf (buf
, "Thread %d ", GET_THREAD (pid
));
1357 else if (GET_LWP (pid
) != 0)
1358 sprintf (buf
, "LWP %d ", GET_LWP (pid
));
1360 sprintf (buf
, "process %d ", PIDGET (pid
));
1366 /* Worker bee for find_new_threads
1367 Callback function that gets called once per USER thread (i.e., not
1371 sol_find_new_threads_callback(th
, ignored
)
1372 const td_thrhandle_t
*th
;
1379 if ((retval
= p_td_thr_get_info(th
, &ti
)) != TD_OK
)
1383 pid
= BUILD_THREAD(ti
.ti_tid
, PIDGET(inferior_pid
));
1384 if (!in_thread_list(pid
))
1391 sol_find_new_threads()
1393 /* don't do anything if init failed to resolve the libthread_db library */
1394 if (!procfs_suppress_run
)
1397 if (inferior_pid
== -1)
1399 printf_filtered("No process.\n");
1402 p_td_ta_thr_iter (main_ta
, sol_find_new_threads_callback
, (void *)0,
1403 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1404 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1408 sol_core_open (filename
, from_tty
)
1412 orig_core_ops
.to_open (filename
, from_tty
);
1416 sol_core_close (quitting
)
1419 orig_core_ops
.to_close (quitting
);
1423 sol_core_detach (args
, from_tty
)
1427 unpush_target (&core_ops
);
1428 orig_core_ops
.to_detach (args
, from_tty
);
1432 sol_core_files_info (t
)
1433 struct target_ops
*t
;
1435 orig_core_ops
.to_files_info (t
);
1438 #ifdef MAINTENANCE_CMDS
1439 /* Worker bee for info sol-thread command. This is a callback function that
1440 gets called once for each Solaris thread (ie. not kernel thread) in the
1441 inferior. Print anything interesting that we can think of. */
1445 const td_thrhandle_t
*th
;
1450 struct minimal_symbol
*msym
;
1452 if ((ret
= p_td_thr_get_info (th
, &ti
)) == TD_OK
)
1454 printf_filtered ("%s thread #%d, lwp %d, ",
1455 ti
.ti_type
== TD_THR_SYSTEM
? "system" : "user ",
1456 ti
.ti_tid
, ti
.ti_lid
);
1457 switch (ti
.ti_state
) {
1459 case TD_THR_UNKNOWN
: printf_filtered ("<unknown state>"); break;
1460 case TD_THR_STOPPED
: printf_filtered ("(stopped)"); break;
1461 case TD_THR_RUN
: printf_filtered ("(run) "); break;
1462 case TD_THR_ACTIVE
: printf_filtered ("(active) "); break;
1463 case TD_THR_ZOMBIE
: printf_filtered ("(zombie) "); break;
1464 case TD_THR_SLEEP
: printf_filtered ("(asleep) "); break;
1465 case TD_THR_STOPPED_ASLEEP
:
1466 printf_filtered ("(stopped asleep)"); break;
1468 /* Print thr_create start function: */
1469 if (ti
.ti_startfunc
!= 0)
1470 if (msym
= lookup_minimal_symbol_by_pc (ti
.ti_startfunc
))
1471 printf_filtered (" startfunc: %s\n", SYMBOL_NAME (msym
));
1473 printf_filtered (" startfunc: 0x%08x\n", ti
.ti_startfunc
);
1475 /* If thread is asleep, print function that went to sleep: */
1476 if (ti
.ti_state
== TD_THR_SLEEP
)
1477 if (msym
= lookup_minimal_symbol_by_pc (ti
.ti_pc
))
1478 printf_filtered (" - Sleep func: %s\n", SYMBOL_NAME (msym
));
1480 printf_filtered (" - Sleep func: 0x%08x\n", ti
.ti_startfunc
);
1482 /* Wrap up line, if necessary */
1483 if (ti
.ti_state
!= TD_THR_SLEEP
&& ti
.ti_startfunc
== 0)
1484 printf_filtered ("\n"); /* don't you hate counting newlines? */
1487 warning ("info sol-thread: failed to get info for thread.");
1492 /* List some state about each Solaris user thread in the inferior. */
1495 info_solthreads (args
, from_tty
)
1499 p_td_ta_thr_iter (main_ta
, info_cb
, args
,
1500 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1501 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1503 #endif /* MAINTENANCE_CMDS */
1506 ignore (addr
, contents
)
1513 struct target_ops sol_thread_ops
= {
1514 "solaris-threads", /* to_shortname */
1515 "Solaris threads and pthread.", /* to_longname */
1516 "Solaris threads and pthread support.", /* to_doc */
1517 sol_thread_open
, /* to_open */
1519 sol_thread_attach
, /* to_attach */
1520 sol_thread_detach
, /* to_detach */
1521 sol_thread_resume
, /* to_resume */
1522 sol_thread_wait
, /* to_wait */
1523 sol_thread_fetch_registers
, /* to_fetch_registers */
1524 sol_thread_store_registers
, /* to_store_registers */
1525 sol_thread_prepare_to_store
, /* to_prepare_to_store */
1526 sol_thread_xfer_memory
, /* to_xfer_memory */
1527 sol_thread_files_info
, /* to_files_info */
1528 memory_insert_breakpoint
, /* to_insert_breakpoint */
1529 memory_remove_breakpoint
, /* to_remove_breakpoint */
1530 terminal_init_inferior
, /* to_terminal_init */
1531 terminal_inferior
, /* to_terminal_inferior */
1532 terminal_ours_for_output
, /* to_terminal_ours_for_output */
1533 terminal_ours
, /* to_terminal_ours */
1534 child_terminal_info
, /* to_terminal_info */
1535 sol_thread_kill_inferior
, /* to_kill */
1537 0, /* to_lookup_symbol */
1538 sol_thread_create_inferior
, /* to_create_inferior */
1539 sol_thread_mourn_inferior
, /* to_mourn_inferior */
1540 sol_thread_can_run
, /* to_can_run */
1541 sol_thread_notice_signals
, /* to_notice_signals */
1542 sol_thread_alive
, /* to_thread_alive */
1543 sol_thread_stop
, /* to_stop */
1544 process_stratum
, /* to_stratum */
1546 1, /* to_has_all_memory */
1547 1, /* to_has_memory */
1548 1, /* to_has_stack */
1549 1, /* to_has_registers */
1550 1, /* to_has_execution */
1552 0, /* sections_end */
1553 OPS_MAGIC
/* to_magic */
1556 struct target_ops sol_core_ops
= {
1557 "solaris-core", /* to_shortname */
1558 "Solaris core threads and pthread.", /* to_longname */
1559 "Solaris threads and pthread support for core files.", /* to_doc */
1560 sol_core_open
, /* to_open */
1561 sol_core_close
, /* to_close */
1562 sol_thread_attach
, /* XXX to_attach */
1563 sol_core_detach
, /* to_detach */
1566 sol_thread_fetch_registers
, /* to_fetch_registers */
1567 0, /* to_store_registers */
1568 0, /* to_prepare_to_store */
1569 sol_thread_xfer_memory
, /* XXX to_xfer_memory */
1570 sol_core_files_info
, /* to_files_info */
1571 ignore
, /* to_insert_breakpoint */
1572 ignore
, /* to_remove_breakpoint */
1573 0, /* to_terminal_init */
1574 0, /* to_terminal_inferior */
1575 0, /* to_terminal_ours_for_output */
1576 0, /* to_terminal_ours */
1577 0, /* to_terminal_info */
1580 0, /* to_lookup_symbol */
1581 sol_thread_create_inferior
, /* XXX to_create_inferior */
1582 0, /* to_mourn_inferior */
1584 0, /* to_notice_signals */
1585 0, /* to_thread_alive */
1587 core_stratum
, /* to_stratum */
1589 0, /* to_has_all_memory */
1590 1, /* to_has_memory */
1591 1, /* to_has_stack */
1592 1, /* to_has_registers */
1593 0, /* to_has_execution */
1595 0, /* sections_end */
1596 OPS_MAGIC
/* to_magic */
1599 /* we suppress the call to add_target of core_ops in corelow because
1600 if there are two targets in the stratum core_stratum, find_core_target
1601 won't know which one to return. see corelow.c for an additonal
1602 comment on coreops_suppress_target. */
1603 int coreops_suppress_target
= 1;
1606 _initialize_sol_thread ()
1610 dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
);
1614 #define resolve(X) \
1615 if (!(p_##X = dlsym (dlhandle, #X))) \
1619 resolve (td_ta_new
);
1620 resolve (td_ta_delete
);
1622 resolve (td_ta_get_ph
);
1623 resolve (td_ta_get_nthreads
);
1624 resolve (td_ta_tsd_iter
);
1625 resolve (td_ta_thr_iter
);
1626 resolve (td_thr_validate
);
1627 resolve (td_thr_tsd
);
1628 resolve (td_thr_get_info
);
1629 resolve (td_thr_getfpregs
);
1630 resolve (td_thr_getxregsize
);
1631 resolve (td_thr_getxregs
);
1632 resolve (td_thr_sigsetmask
);
1633 resolve (td_thr_setprio
);
1634 resolve (td_thr_setsigpending
);
1635 resolve (td_thr_setfpregs
);
1636 resolve (td_thr_setxregs
);
1637 resolve (td_ta_map_id2thr
);
1638 resolve (td_ta_map_lwp2thr
);
1639 resolve (td_thr_getgregs
);
1640 resolve (td_thr_setgregs
);
1642 add_target (&sol_thread_ops
);
1644 procfs_suppress_run
= 1;
1646 #ifdef MAINTENANCE_CMDS
1647 add_cmd ("sol-threads", class_maintenance
, info_solthreads
,
1648 "Show info on Solaris user threads.\n", &maintenanceinfolist
);
1649 #endif /* MAINTENANCE_CMDS */
1651 memcpy(&orig_core_ops
, &core_ops
, sizeof (struct target_ops
));
1652 memcpy(&core_ops
, &sol_core_ops
, sizeof (struct target_ops
));
1653 add_target (&core_ops
);
1659 fprintf_unfiltered (gdb_stderr
, "[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
1664 /* allow the user to debug non-threaded core files */
1665 add_target(&core_ops
);