1 /* Low level interface for debugging Solaris threads for GDB, the GNU debugger.
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* This module implements a sort of half target that sits between the
23 machine-independent parts of GDB and the /proc interface (procfs.c) to
24 provide access to the Solaris user-mode thread implementation.
26 Solaris threads are true user-mode threads, which are invoked via the thr_*
27 and pthread_* (native and Posix respectivly) interfaces. These are mostly
28 implemented in user-space, with all thread context kept in various
29 structures that live in the user's heap. These should not be confused with
30 lightweight processes (LWPs), which are implemented by the kernel, and
31 scheduled without explicit intervention by the process.
33 Just to confuse things a little, Solaris threads (both native and Posix) are
34 actually implemented using LWPs. In general, there are going to be more
35 threads than LWPs. There is no fixed correspondence between a thread and an
36 LWP. When a thread wants to run, it gets scheduled onto the first available
37 LWP and can therefore migrate from one LWP to another as time goes on. A
38 sleeping thread may not be associated with an LWP at all!
40 To make it possible to mess with threads, Sun provides a library called
41 libthread_db.so.1 (not to be confused with libthread_db.so.0, which doesn't
42 have a published interface). This interface has an upper part, which it
43 provides, and a lower part which I provide. The upper part consists of the
44 td_* routines, which allow me to find all the threads, query their state,
45 etc... The lower part consists of all of the ps_*, which are used by the
46 td_* routines to read/write memory, manipulate LWPs, lookup symbols, etc...
47 The ps_* routines actually do most of their work by calling functions in
52 #include <proc_service.h>
53 #include <thread_db.h>
54 #include "gdbthread.h"
64 extern struct target_ops sol_thread_ops
; /* Forward declaration */
65 extern struct target_ops sol_core_ops
; /* Forward declaration */
67 /* place to store core_ops before we overwrite it */
68 static struct target_ops orig_core_ops
;
70 struct target_ops sol_thread_ops
;
71 struct target_ops sol_core_ops
;
73 extern int procfs_suppress_run
;
74 extern struct target_ops procfs_ops
; /* target vector for procfs.c */
75 extern struct target_ops core_ops
; /* target vector for corelow.c */
76 extern char *procfs_pid_to_str (int pid
);
78 /* Prototypes for supply_gregset etc. */
81 /* This struct is defined by us, but mainly used for the proc_service interface.
82 We don't have much use for it, except as a handy place to get a real pid
83 for memory accesses. */
96 static struct ps_prochandle main_ph
;
97 static td_thragent_t
*main_ta
;
98 static int sol_thread_active
= 0;
100 static struct cleanup
*save_inferior_pid (void);
101 static void restore_inferior_pid (void *pid
);
102 static char *td_err_string (td_err_e errcode
);
103 static char *td_state_string (td_thr_state_e statecode
);
104 static int thread_to_lwp (int thread_id
, int default_lwp
);
105 static void sol_thread_resume (int pid
, int step
, enum target_signal signo
);
106 static int lwp_to_thread (int lwp
);
107 static int sol_thread_alive (int pid
);
108 static void sol_core_close (int quitting
);
110 static void init_sol_thread_ops (void);
111 static void init_sol_core_ops (void);
113 /* Default definitions: These must be defined in tm.h
114 if they are to be shared with a process module such as procfs. */
116 #define THREAD_FLAG 0x80000000
117 #define is_thread(ARG) (((ARG) & THREAD_FLAG) != 0)
118 #define is_lwp(ARG) (((ARG) & THREAD_FLAG) == 0)
119 #define GET_LWP(PID) TIDGET (PID)
120 #define GET_THREAD(PID) TIDGET (PID)
121 #define BUILD_LWP(TID, PID) MERGEPID (PID, TID)
123 #define BUILD_THREAD(TID, PID) (MERGEPID (PID, TID) | THREAD_FLAG)
125 /* Pointers to routines from lithread_db resolved by dlopen() */
127 static void (*p_td_log
) (const int on_off
);
128 static td_err_e (*p_td_ta_new
) (const struct ps_prochandle
* ph_p
,
129 td_thragent_t
** ta_pp
);
130 static td_err_e (*p_td_ta_delete
) (td_thragent_t
* ta_p
);
131 static td_err_e (*p_td_init
) (void);
132 static td_err_e (*p_td_ta_get_ph
) (const td_thragent_t
* ta_p
,
133 struct ps_prochandle
** ph_pp
);
134 static td_err_e (*p_td_ta_get_nthreads
) (const td_thragent_t
* ta_p
,
136 static td_err_e (*p_td_ta_tsd_iter
) (const td_thragent_t
* ta_p
,
139 static td_err_e (*p_td_ta_thr_iter
) (const td_thragent_t
* ta_p
,
142 td_thr_state_e state
,
144 sigset_t
* ti_sigmask_p
,
145 unsigned ti_user_flags
);
146 static td_err_e (*p_td_thr_validate
) (const td_thrhandle_t
* th_p
);
147 static td_err_e (*p_td_thr_tsd
) (const td_thrhandle_t
* th_p
,
148 const thread_key_t key
,
150 static td_err_e (*p_td_thr_get_info
) (const td_thrhandle_t
* th_p
,
151 td_thrinfo_t
* ti_p
);
152 static td_err_e (*p_td_thr_getfpregs
) (const td_thrhandle_t
* th_p
,
153 prfpregset_t
* fpregset
);
154 static td_err_e (*p_td_thr_getxregsize
) (const td_thrhandle_t
* th_p
,
156 static td_err_e (*p_td_thr_getxregs
) (const td_thrhandle_t
* th_p
,
157 const caddr_t xregset
);
158 static td_err_e (*p_td_thr_sigsetmask
) (const td_thrhandle_t
* th_p
,
159 const sigset_t ti_sigmask
);
160 static td_err_e (*p_td_thr_setprio
) (const td_thrhandle_t
* th_p
,
162 static td_err_e (*p_td_thr_setsigpending
) (const td_thrhandle_t
* th_p
,
163 const uchar_t ti_pending_flag
,
164 const sigset_t ti_pending
);
165 static td_err_e (*p_td_thr_setfpregs
) (const td_thrhandle_t
* th_p
,
166 const prfpregset_t
* fpregset
);
167 static td_err_e (*p_td_thr_setxregs
) (const td_thrhandle_t
* th_p
,
168 const caddr_t xregset
);
169 static td_err_e (*p_td_ta_map_id2thr
) (const td_thragent_t
* ta_p
,
171 td_thrhandle_t
* th_p
);
172 static td_err_e (*p_td_ta_map_lwp2thr
) (const td_thragent_t
* ta_p
,
174 td_thrhandle_t
* th_p
);
175 static td_err_e (*p_td_thr_getgregs
) (const td_thrhandle_t
* th_p
,
177 static td_err_e (*p_td_thr_setgregs
) (const td_thrhandle_t
* th_p
,
178 const prgregset_t regset
);
184 td_err_string - Convert a thread_db error code to a string
188 char * td_err_string (errcode)
192 Return the thread_db error string associated with errcode. If errcode
193 is unknown, then return a message.
198 td_err_string (td_err_e errcode
)
200 static struct string_map
203 {TD_OK
, "generic \"call succeeded\""},
204 {TD_ERR
, "generic error."},
205 {TD_NOTHR
, "no thread can be found to satisfy query"},
206 {TD_NOSV
, "no synch. variable can be found to satisfy query"},
207 {TD_NOLWP
, "no lwp can be found to satisfy query"},
208 {TD_BADPH
, "invalid process handle"},
209 {TD_BADTH
, "invalid thread handle"},
210 {TD_BADSH
, "invalid synchronization handle"},
211 {TD_BADTA
, "invalid thread agent"},
212 {TD_BADKEY
, "invalid key"},
213 {TD_NOMSG
, "td_thr_event_getmsg() called when there was no message"},
214 {TD_NOFPREGS
, "FPU register set not available for given thread"},
215 {TD_NOLIBTHREAD
, "application not linked with libthread"},
216 {TD_NOEVENT
, "requested event is not supported"},
217 {TD_NOCAPAB
, "capability not available"},
218 {TD_DBERR
, "Debugger service failed"},
219 {TD_NOAPLIC
, "Operation not applicable to"},
220 {TD_NOTSD
, "No thread specific data for this thread"},
221 {TD_MALLOC
, "Malloc failed"},
222 {TD_PARTIALREG
, "Only part of register set was written/read"},
223 {TD_NOXREGS
, "X register set not available for given thread"}
225 const int td_err_size
= sizeof td_err_table
/ sizeof (struct string_map
);
229 for (i
= 0; i
< td_err_size
; i
++)
230 if (td_err_table
[i
].num
== errcode
)
231 return td_err_table
[i
].str
;
233 sprintf (buf
, "Unknown thread_db error code: %d", errcode
);
242 td_state_string - Convert a thread_db state code to a string
246 char * td_state_string (statecode)
250 Return the thread_db state string associated with statecode. If
251 statecode is unknown, then return a message.
256 td_state_string (td_thr_state_e statecode
)
258 static struct string_map
259 td_thr_state_table
[] =
261 {TD_THR_ANY_STATE
, "any state"},
262 {TD_THR_UNKNOWN
, "unknown"},
263 {TD_THR_STOPPED
, "stopped"},
265 {TD_THR_ACTIVE
, "active"},
266 {TD_THR_ZOMBIE
, "zombie"},
267 {TD_THR_SLEEP
, "sleep"},
268 {TD_THR_STOPPED_ASLEEP
, "stopped asleep"}
270 const int td_thr_state_table_size
= sizeof td_thr_state_table
/ sizeof (struct string_map
);
274 for (i
= 0; i
< td_thr_state_table_size
; i
++)
275 if (td_thr_state_table
[i
].num
== statecode
)
276 return td_thr_state_table
[i
].str
;
278 sprintf (buf
, "Unknown thread_db state code: %d", statecode
);
287 thread_to_lwp - Convert a Posix or Solaris thread id to a LWP id.
291 int thread_to_lwp (thread_id, default_lwp)
295 This function converts a Posix or Solaris thread id to a lightweight
296 process id. If thread_id is non-existent, that's an error. If it's
297 an inactive thread, then we return default_lwp.
301 This function probably shouldn't call error()...
306 thread_to_lwp (int thread_id
, int 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()...
362 lwp_to_thread (int lwp
)
369 return lwp
; /* It's already a thread id */
371 /* It's an lwp. Convert it to a thread id. */
373 if (!sol_thread_alive (lwp
))
374 return -1; /* defunct lwp */
376 val
= p_td_ta_map_lwp2thr (main_ta
, GET_LWP (lwp
), &th
);
378 return -1; /* thread must have terminated */
379 else if (val
!= TD_OK
)
380 error ("lwp_to_thread: td_ta_map_lwp2thr: %s.", td_err_string (val
));
382 val
= p_td_thr_validate (&th
);
384 return lwp
; /* libthread doesn't know about it;
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
*
427 save_inferior_pid (void)
429 int *saved_pid
= xmalloc (sizeof (int));
430 *saved_pid
= inferior_pid
;
431 return make_cleanup (restore_inferior_pid
, saved_pid
);
435 restore_inferior_pid (void *data
)
437 int *saved_pid
= data
;
438 inferior_pid
= *saved_pid
;
443 /* Most target vector functions from here on actually just pass through to
444 procfs.c, as they don't need to do anything specific for threads. */
449 sol_thread_open (char *arg
, int from_tty
)
451 procfs_ops
.to_open (arg
, from_tty
);
454 /* Attach to process PID, then initialize for debugging it
455 and wait for the trace-trap that results from attaching. */
458 sol_thread_attach (char *args
, int from_tty
)
460 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);
465 if (sol_thread_active
)
467 printf_filtered ("sol-thread active.\n");
468 main_ph
.pid
= inferior_pid
; /* Save for xfer_memory */
469 push_target (&sol_thread_ops
);
470 inferior_pid
= lwp_to_thread (inferior_pid
);
471 if (inferior_pid
== -1)
472 inferior_pid
= main_ph
.pid
;
474 add_thread (inferior_pid
);
476 /* XXX - might want to iterate over all the threads and register them. */
479 /* Take a program previously attached to and detaches it.
480 The program resumes execution and will no longer stop
481 on signals, etc. We'd better not have left any breakpoints
482 in the program or it'll die when it hits one. For this
483 to work, it may be necessary for the process to have been
484 previously attached. It *might* work if the program was
485 started via the normal ptrace (PTRACE_TRACEME). */
488 sol_thread_detach (char *args
, int from_tty
)
490 inferior_pid
= PIDGET (main_ph
.pid
);
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 (int pid
, int step
, enum target_signal signo
)
503 struct cleanup
*old_chain
;
505 old_chain
= save_inferior_pid ();
507 inferior_pid
= thread_to_lwp (inferior_pid
, main_ph
.pid
);
508 if (inferior_pid
== -1)
509 inferior_pid
= procfs_first_available ();
515 pid
= thread_to_lwp (pid
, -2);
516 if (pid
== -2) /* Inactive thread */
517 error ("This version of Solaris can't start inactive threads.");
518 if (info_verbose
&& pid
== -1)
519 warning ("Specified thread %d seems to have terminated",
520 GET_THREAD (save_pid
));
523 procfs_ops
.to_resume (pid
, step
, signo
);
525 do_cleanups (old_chain
);
528 /* Wait for any threads to stop. We may have to convert PID from a thread id
529 to a LWP id, and vice versa on the way out. */
532 sol_thread_wait (int pid
, struct target_waitstatus
*ourstatus
)
536 struct cleanup
*old_chain
;
538 save_pid
= inferior_pid
;
539 old_chain
= save_inferior_pid ();
541 inferior_pid
= thread_to_lwp (inferior_pid
, main_ph
.pid
);
542 if (inferior_pid
== -1)
543 inferior_pid
= procfs_first_available ();
549 pid
= thread_to_lwp (pid
, -2);
550 if (pid
== -2) /* Inactive thread */
551 error ("This version of Solaris can't start inactive threads.");
552 if (info_verbose
&& pid
== -1)
553 warning ("Specified thread %d seems to have terminated",
554 GET_THREAD (save_pid
));
557 rtnval
= procfs_ops
.to_wait (pid
, ourstatus
);
559 if (ourstatus
->kind
!= TARGET_WAITKIND_EXITED
)
561 /* Map the LWP of interest back to the appropriate thread ID */
562 rtnval
= lwp_to_thread (rtnval
);
566 /* See if we have a new thread */
567 if (is_thread (rtnval
)
568 && rtnval
!= save_pid
569 && !in_thread_list (rtnval
))
571 printf_filtered ("[New %s]\n", target_pid_to_str (rtnval
));
576 /* During process initialization, we may get here without the thread package
577 being initialized, since that can only happen after we've found the shared
580 do_cleanups (old_chain
);
586 sol_thread_fetch_registers (int regno
)
589 td_thrhandle_t thandle
;
592 prfpregset_t fpregset
;
598 if (!is_thread (inferior_pid
))
599 { /* LWP: pass the request on to procfs.c */
600 if (target_has_execution
)
601 procfs_ops
.to_fetch_registers (regno
);
603 orig_core_ops
.to_fetch_registers (regno
);
607 /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
609 thread
= GET_THREAD (inferior_pid
);
612 error ("sol_thread_fetch_registers: thread == 0");
614 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
616 error ("sol_thread_fetch_registers: td_ta_map_id2thr: %s",
617 td_err_string (val
));
619 /* Get the integer regs */
621 val
= p_td_thr_getgregs (&thandle
, gregset
);
623 && val
!= TD_PARTIALREG
)
624 error ("sol_thread_fetch_registers: td_thr_getgregs %s",
625 td_err_string (val
));
627 /* For the sparc, TD_PARTIALREG means that only i0->i7, l0->l7, pc and sp
628 are saved (by a thread context switch). */
630 /* And, now the fp regs */
632 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
634 && val
!= TD_NOFPREGS
)
635 error ("sol_thread_fetch_registers: td_thr_getfpregs %s",
636 td_err_string (val
));
638 /* Note that we must call supply_{g fp}regset *after* calling the td routines
639 because the td routines call ps_lget* which affect the values stored in the
642 supply_gregset ((gdb_gregset_t
*) &gregset
);
643 supply_fpregset ((gdb_fpregset_t
*) &fpregset
);
646 /* thread_db doesn't seem to handle this right */
647 val
= td_thr_getxregsize (&thandle
, &xregsize
);
648 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
649 error ("sol_thread_fetch_registers: td_thr_getxregsize %s",
650 td_err_string (val
));
654 xregset
= alloca (xregsize
);
655 val
= td_thr_getxregs (&thandle
, xregset
);
657 error ("sol_thread_fetch_registers: td_thr_getxregs %s",
658 td_err_string (val
));
664 sol_thread_store_registers (int regno
)
667 td_thrhandle_t thandle
;
670 prfpregset_t fpregset
;
676 if (!is_thread (inferior_pid
))
677 { /* LWP: pass the request on to procfs.c */
678 procfs_ops
.to_store_registers (regno
);
682 /* Solaris thread: convert inferior_pid into a td_thrhandle_t */
684 thread
= GET_THREAD (inferior_pid
);
686 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
688 error ("sol_thread_store_registers: td_ta_map_id2thr %s",
689 td_err_string (val
));
692 { /* Not writing all the regs */
693 /* save new register value */
694 char* old_value
= (char*) alloca (REGISTER_SIZE
);
695 memcpy (old_value
, ®isters
[REGISTER_BYTE (regno
)], REGISTER_SIZE
);
697 val
= p_td_thr_getgregs (&thandle
, gregset
);
699 error ("sol_thread_store_registers: td_thr_getgregs %s",
700 td_err_string (val
));
701 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
703 error ("sol_thread_store_registers: td_thr_getfpregs %s",
704 td_err_string (val
));
706 /* restore new register value */
707 memcpy (®isters
[REGISTER_BYTE (regno
)], old_value
, REGISTER_SIZE
);
710 /* thread_db doesn't seem to handle this right */
711 val
= td_thr_getxregsize (&thandle
, &xregsize
);
712 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
713 error ("sol_thread_store_registers: td_thr_getxregsize %s",
714 td_err_string (val
));
718 xregset
= alloca (xregsize
);
719 val
= td_thr_getxregs (&thandle
, xregset
);
721 error ("sol_thread_store_registers: td_thr_getxregs %s",
722 td_err_string (val
));
727 fill_gregset ((gdb_gregset_t
*) &gregset
, regno
);
728 fill_fpregset ((gdb_fpregset_t
*) &fpregset
, regno
);
730 val
= p_td_thr_setgregs (&thandle
, gregset
);
732 error ("sol_thread_store_registers: td_thr_setgregs %s",
733 td_err_string (val
));
734 val
= p_td_thr_setfpregs (&thandle
, &fpregset
);
736 error ("sol_thread_store_registers: td_thr_setfpregs %s",
737 td_err_string (val
));
740 /* thread_db doesn't seem to handle this right */
741 val
= td_thr_getxregsize (&thandle
, &xregsize
);
742 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
743 error ("sol_thread_store_registers: td_thr_getxregsize %s",
744 td_err_string (val
));
746 /* Should probably do something about writing the xregs here, but what are
751 /* Get ready to modify the registers array. On machines which store
752 individual registers, this doesn't need to do anything. On machines
753 which store all the registers in one fell swoop, this makes sure
754 that registers contains all the registers from the program being
758 sol_thread_prepare_to_store (void)
760 procfs_ops
.to_prepare_to_store ();
763 /* Transfer LEN bytes between GDB address MYADDR and target address
764 MEMADDR. If DOWRITE is non-zero, transfer them to the target,
765 otherwise transfer them from the target. TARGET is unused.
767 Returns the number of bytes transferred. */
770 sol_thread_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int dowrite
,
771 struct mem_attrib
*attrib
,
772 struct target_ops
*target
)
775 struct cleanup
*old_chain
;
777 old_chain
= save_inferior_pid ();
779 if (is_thread (inferior_pid
) || /* A thread */
780 !target_thread_alive (inferior_pid
)) /* An lwp, but not alive */
781 inferior_pid
= procfs_first_available (); /* Find any live lwp. */
782 /* Note: don't need to call switch_to_thread; we're just reading memory. */
784 if (target_has_execution
)
785 retval
= procfs_ops
.to_xfer_memory (memaddr
, myaddr
, len
,
786 dowrite
, attrib
, target
);
788 retval
= orig_core_ops
.to_xfer_memory (memaddr
, myaddr
, len
,
789 dowrite
, attrib
, target
);
791 do_cleanups (old_chain
);
796 /* Print status information about what we're accessing. */
799 sol_thread_files_info (struct target_ops
*ignore
)
801 procfs_ops
.to_files_info (ignore
);
805 sol_thread_kill_inferior (void)
807 procfs_ops
.to_kill ();
811 sol_thread_notice_signals (int pid
)
813 procfs_ops
.to_notice_signals (PIDGET (pid
));
816 /* Fork an inferior process, and start debugging it with /proc. */
819 sol_thread_create_inferior (char *exec_file
, char *allargs
, char **env
)
821 procfs_ops
.to_create_inferior (exec_file
, allargs
, env
);
823 if (sol_thread_active
&& inferior_pid
!= 0)
825 main_ph
.pid
= inferior_pid
; /* Save for xfer_memory */
827 push_target (&sol_thread_ops
);
829 inferior_pid
= lwp_to_thread (inferior_pid
);
830 if (inferior_pid
== -1)
831 inferior_pid
= main_ph
.pid
;
833 if (!in_thread_list (inferior_pid
))
834 add_thread (inferior_pid
);
838 /* This routine is called whenever a new symbol table is read in, or when all
839 symbol tables are removed. libthread_db can only be initialized when it
840 finds the right variables in libthread.so. Since it's a shared library,
841 those variables don't show up until the library gets mapped and the symbol
844 /* This new_objfile event is now managed by a chained function pointer.
845 * It is the callee's responsability to call the next client on the chain.
848 /* Saved pointer to previous owner of the new_objfile event. */
849 static void (*target_new_objfile_chain
) (struct objfile
*);
852 sol_thread_new_objfile (struct objfile
*objfile
)
858 sol_thread_active
= 0;
862 /* don't do anything if init failed to resolve the libthread_db library */
863 if (!procfs_suppress_run
)
866 /* Now, initialize the thread debugging library. This needs to be done after
867 the shared libraries are located because it needs information from the
868 user's thread library. */
873 warning ("sol_thread_new_objfile: td_init: %s", td_err_string (val
));
877 val
= p_td_ta_new (&main_ph
, &main_ta
);
878 if (val
== TD_NOLIBTHREAD
)
880 else if (val
!= TD_OK
)
882 warning ("sol_thread_new_objfile: td_ta_new: %s", td_err_string (val
));
886 sol_thread_active
= 1;
888 /* Call predecessor on chain, if any. */
889 if (target_new_objfile_chain
)
890 target_new_objfile_chain (objfile
);
893 /* Clean up after the inferior dies. */
896 sol_thread_mourn_inferior (void)
898 unpush_target (&sol_thread_ops
);
899 procfs_ops
.to_mourn_inferior ();
902 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
905 sol_thread_can_run (void)
907 return procfs_suppress_run
;
914 sol_thread_alive - test thread for "aliveness"
918 static bool sol_thread_alive (int pid);
922 returns true if thread still active in inferior.
927 sol_thread_alive (int 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 */
942 /* kernel thread (LWP): let procfs test it */
944 if (target_has_execution
)
945 return procfs_ops
.to_thread_alive (pid
);
947 return orig_core_ops
.to_thread_alive (pid
);
952 sol_thread_stop (void)
954 procfs_ops
.to_stop ();
957 /* These routines implement the lower half of the thread_db interface. Ie: the
960 /* Various versions of <proc_service.h> have slightly
961 different function prototypes. In particular, we have
964 struct ps_prochandle * const struct ps_prochandle *
969 Which one you have depends on solaris version and what
970 patches you've applied. On the theory that there are
971 only two major variants, we have configure check the
972 prototype of ps_pdwrite (), and use that info to make
973 appropriate typedefs here. */
975 #ifdef PROC_SERVICE_IS_OLD
976 typedef const struct ps_prochandle
*gdb_ps_prochandle_t
;
977 typedef char *gdb_ps_read_buf_t
;
978 typedef char *gdb_ps_write_buf_t
;
979 typedef int gdb_ps_size_t
;
980 typedef paddr_t gdb_ps_addr_t
;
982 typedef struct ps_prochandle
*gdb_ps_prochandle_t
;
983 typedef void *gdb_ps_read_buf_t
;
984 typedef const void *gdb_ps_write_buf_t
;
985 typedef size_t gdb_ps_size_t
;
986 typedef psaddr_t gdb_ps_addr_t
;
990 /* The next four routines are called by thread_db to tell us to stop and stop
991 a particular process or lwp. Since GDB ensures that these are all stopped
992 by the time we call anything in thread_db, these routines need to do
998 ps_pstop (gdb_ps_prochandle_t ph
)
1003 /* Process continue */
1006 ps_pcontinue (gdb_ps_prochandle_t ph
)
1014 ps_lstop (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
1022 ps_lcontinue (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
1027 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
1030 ps_pglobal_lookup (gdb_ps_prochandle_t ph
, const char *ld_object_name
,
1031 const char *ld_symbol_name
, gdb_ps_addr_t
* ld_symbol_addr
)
1033 struct minimal_symbol
*ms
;
1035 ms
= lookup_minimal_symbol (ld_symbol_name
, NULL
, NULL
);
1040 *ld_symbol_addr
= SYMBOL_VALUE_ADDRESS (ms
);
1045 /* Common routine for reading and writing memory. */
1048 rw_common (int dowrite
, const struct ps_prochandle
*ph
, gdb_ps_addr_t addr
,
1049 char *buf
, int size
)
1051 struct cleanup
*old_chain
;
1053 old_chain
= save_inferior_pid ();
1055 if (is_thread (inferior_pid
) || /* A thread */
1056 !target_thread_alive (inferior_pid
)) /* An lwp, but not alive */
1057 inferior_pid
= procfs_first_available (); /* Find any live lwp. */
1058 /* Note: don't need to call switch_to_thread; we're just reading memory. */
1060 #if defined (__sparcv9)
1061 /* For Sparc64 cross Sparc32, make sure the address has not been
1062 accidentally sign-extended (or whatever) to beyond 32 bits. */
1063 if (bfd_get_arch_size (exec_bfd
) == 32)
1071 /* FIXME: passing 0 as attrib argument. */
1072 if (target_has_execution
)
1073 cc
= procfs_ops
.to_xfer_memory (addr
, buf
, size
,
1074 dowrite
, 0, &procfs_ops
);
1076 cc
= orig_core_ops
.to_xfer_memory (addr
, buf
, size
,
1077 dowrite
, 0, &core_ops
);
1082 print_sys_errmsg ("rw_common (): read", errno
);
1084 print_sys_errmsg ("rw_common (): write", errno
);
1086 do_cleanups (old_chain
);
1093 warning ("rw_common (): unable to read at addr 0x%lx",
1096 warning ("rw_common (): unable to write at addr 0x%lx",
1099 do_cleanups (old_chain
);
1108 do_cleanups (old_chain
);
1113 /* Copies SIZE bytes from target process .data segment to debugger memory. */
1116 ps_pdread (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
1117 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
1119 return rw_common (0, ph
, addr
, buf
, size
);
1122 /* Copies SIZE bytes from debugger memory .data segment to target process. */
1125 ps_pdwrite (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
1126 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
1128 return rw_common (1, ph
, addr
, (char *) buf
, size
);
1131 /* Copies SIZE bytes from target process .text segment to debugger memory. */
1134 ps_ptread (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
1135 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
1137 return rw_common (0, ph
, addr
, buf
, size
);
1140 /* Copies SIZE bytes from debugger memory .text segment to target process. */
1143 ps_ptwrite (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
1144 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
1146 return rw_common (1, ph
, addr
, (char *) buf
, size
);
1149 /* Get integer regs for LWP */
1152 ps_lgetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1153 prgregset_t gregset
)
1155 struct cleanup
*old_chain
;
1157 old_chain
= save_inferior_pid ();
1159 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1161 if (target_has_execution
)
1162 procfs_ops
.to_fetch_registers (-1);
1164 orig_core_ops
.to_fetch_registers (-1);
1165 fill_gregset ((gdb_gregset_t
*) gregset
, -1);
1167 do_cleanups (old_chain
);
1172 /* Set integer regs for LWP */
1175 ps_lsetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1176 const prgregset_t gregset
)
1178 struct cleanup
*old_chain
;
1180 old_chain
= save_inferior_pid ();
1182 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1184 supply_gregset ((gdb_gregset_t
*) gregset
);
1185 if (target_has_execution
)
1186 procfs_ops
.to_store_registers (-1);
1188 orig_core_ops
.to_store_registers (-1);
1190 do_cleanups (old_chain
);
1195 /* Log a message (sends to gdb_stderr). */
1198 ps_plog (const char *fmt
,...)
1202 va_start (args
, fmt
);
1204 vfprintf_filtered (gdb_stderr
, fmt
, args
);
1207 /* Get size of extra register set. Currently a noop. */
1210 ps_lgetxregsize (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, int *xregsize
)
1217 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1221 if (ioctl (lwp_fd
, PIOCGXREGSIZE
, ®size
))
1223 if (errno
== EINVAL
)
1224 return PS_NOFREGS
; /* XXX Wrong code, but this is the closest
1225 thing in proc_service.h */
1227 print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno
);
1235 /* Get extra register set. Currently a noop. */
1238 ps_lgetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
1244 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1248 if (ioctl (lwp_fd
, PIOCGXREG
, xregset
))
1250 print_sys_errmsg ("ps_lgetxregs (): PIOCGXREG", errno
);
1258 /* Set extra register set. Currently a noop. */
1261 ps_lsetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
1267 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1271 if (ioctl (lwp_fd
, PIOCSXREG
, xregset
))
1273 print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno
);
1281 /* Get floating-point regs for LWP */
1284 ps_lgetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1285 prfpregset_t
* fpregset
)
1287 struct cleanup
*old_chain
;
1289 old_chain
= save_inferior_pid ();
1291 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1293 if (target_has_execution
)
1294 procfs_ops
.to_fetch_registers (-1);
1296 orig_core_ops
.to_fetch_registers (-1);
1297 fill_fpregset ((gdb_fpregset_t
*) fpregset
, -1);
1299 do_cleanups (old_chain
);
1304 /* Set floating-point regs for LWP */
1307 ps_lsetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1308 const prfpregset_t
* fpregset
)
1310 struct cleanup
*old_chain
;
1312 old_chain
= save_inferior_pid ();
1314 inferior_pid
= BUILD_LWP (lwpid
, PIDGET (inferior_pid
));
1316 supply_fpregset ((gdb_fpregset_t
*) fpregset
);
1317 if (target_has_execution
)
1318 procfs_ops
.to_store_registers (-1);
1320 orig_core_ops
.to_store_registers (-1);
1322 do_cleanups (old_chain
);
1327 #ifdef PR_MODEL_LP64
1328 /* Identify process as 32-bit or 64-bit.
1329 At the moment I'm using bfd to do this.
1330 There might be a more solaris-specific (eg. procfs) method,
1331 but this ought to work. */
1334 ps_pdmodel (gdb_ps_prochandle_t ph
, int *data_model
)
1337 *data_model
= PR_MODEL_UNKNOWN
;
1338 else if (bfd_get_arch_size (exec_bfd
) == 32)
1339 *data_model
= PR_MODEL_ILP32
;
1341 *data_model
= PR_MODEL_LP64
;
1345 #endif /* PR_MODEL_LP64 */
1347 #ifdef TM_I386SOL2_H
1349 /* Reads the local descriptor table of a LWP. */
1352 ps_lgetLDT (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1355 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c */
1356 extern struct ssd
*procfs_find_LDT_entry (int);
1359 /* FIXME: can't I get the process ID from the prochandle or something?
1362 if (inferior_pid
<= 0 || lwpid
<= 0)
1365 ret
= procfs_find_LDT_entry (BUILD_LWP (lwpid
, PIDGET (inferior_pid
)));
1368 memcpy (pldt
, ret
, sizeof (struct ssd
));
1371 else /* LDT not found. */
1374 #endif /* TM_I386SOL2_H */
1376 /* Convert a pid to printable form. */
1379 solaris_pid_to_str (int pid
)
1381 static char buf
[100];
1383 /* in case init failed to resolve the libthread_db library */
1384 if (!procfs_suppress_run
)
1385 return procfs_pid_to_str (pid
);
1387 if (is_thread (pid
))
1391 lwp
= thread_to_lwp (pid
, -2);
1394 sprintf (buf
, "Thread %d (defunct)", GET_THREAD (pid
));
1396 sprintf (buf
, "Thread %d (LWP %d)", GET_THREAD (pid
), GET_LWP (lwp
));
1398 sprintf (buf
, "Thread %d ", GET_THREAD (pid
));
1400 else if (GET_LWP (pid
) != 0)
1401 sprintf (buf
, "LWP %d ", GET_LWP (pid
));
1403 sprintf (buf
, "process %d ", PIDGET (pid
));
1409 /* Worker bee for find_new_threads
1410 Callback function that gets called once per USER thread (i.e., not
1414 sol_find_new_threads_callback (const td_thrhandle_t
*th
, void *ignored
)
1420 if ((retval
= p_td_thr_get_info (th
, &ti
)) != TD_OK
)
1424 pid
= BUILD_THREAD (ti
.ti_tid
, PIDGET (inferior_pid
));
1425 if (!in_thread_list (pid
))
1432 sol_find_new_threads (void)
1434 /* don't do anything if init failed to resolve the libthread_db library */
1435 if (!procfs_suppress_run
)
1438 if (inferior_pid
== -1)
1440 printf_filtered ("No process.\n");
1443 procfs_find_new_threads (); /* first find new kernel threads. */
1444 p_td_ta_thr_iter (main_ta
, sol_find_new_threads_callback
, (void *) 0,
1445 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1446 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1450 sol_core_open (char *filename
, int from_tty
)
1452 orig_core_ops
.to_open (filename
, from_tty
);
1456 sol_core_close (int quitting
)
1458 orig_core_ops
.to_close (quitting
);
1462 sol_core_detach (char *args
, int from_tty
)
1464 unpush_target (&core_ops
);
1465 orig_core_ops
.to_detach (args
, from_tty
);
1469 sol_core_files_info (struct target_ops
*t
)
1471 orig_core_ops
.to_files_info (t
);
1474 /* Worker bee for info sol-thread command. This is a callback function that
1475 gets called once for each Solaris thread (ie. not kernel thread) in the
1476 inferior. Print anything interesting that we can think of. */
1479 info_cb (const td_thrhandle_t
*th
, void *s
)
1484 if ((ret
= p_td_thr_get_info (th
, &ti
)) == TD_OK
)
1486 printf_filtered ("%s thread #%d, lwp %d, ",
1487 ti
.ti_type
== TD_THR_SYSTEM
? "system" : "user ",
1488 ti
.ti_tid
, ti
.ti_lid
);
1489 switch (ti
.ti_state
)
1492 case TD_THR_UNKNOWN
:
1493 printf_filtered ("<unknown state>");
1495 case TD_THR_STOPPED
:
1496 printf_filtered ("(stopped)");
1499 printf_filtered ("(run) ");
1502 printf_filtered ("(active) ");
1505 printf_filtered ("(zombie) ");
1508 printf_filtered ("(asleep) ");
1510 case TD_THR_STOPPED_ASLEEP
:
1511 printf_filtered ("(stopped asleep)");
1514 /* Print thr_create start function: */
1515 if (ti
.ti_startfunc
!= 0)
1517 struct minimal_symbol
*msym
;
1518 msym
= lookup_minimal_symbol_by_pc (ti
.ti_startfunc
);
1520 printf_filtered (" startfunc: %s\n", SYMBOL_NAME (msym
));
1522 printf_filtered (" startfunc: 0x%s\n", paddr (ti
.ti_startfunc
));
1525 /* If thread is asleep, print function that went to sleep: */
1526 if (ti
.ti_state
== TD_THR_SLEEP
)
1528 struct minimal_symbol
*msym
;
1529 msym
= lookup_minimal_symbol_by_pc (ti
.ti_pc
);
1531 printf_filtered (" - Sleep func: %s\n", SYMBOL_NAME (msym
));
1533 printf_filtered (" - Sleep func: 0x%s\n", paddr (ti
.ti_startfunc
));
1536 /* Wrap up line, if necessary */
1537 if (ti
.ti_state
!= TD_THR_SLEEP
&& ti
.ti_startfunc
== 0)
1538 printf_filtered ("\n"); /* don't you hate counting newlines? */
1541 warning ("info sol-thread: failed to get info for thread.");
1546 /* List some state about each Solaris user thread in the inferior. */
1549 info_solthreads (char *args
, int from_tty
)
1551 p_td_ta_thr_iter (main_ta
, info_cb
, args
,
1552 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1553 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1557 ignore (CORE_ADDR addr
, char *contents
)
1564 init_sol_thread_ops (void)
1566 sol_thread_ops
.to_shortname
= "solaris-threads";
1567 sol_thread_ops
.to_longname
= "Solaris threads and pthread.";
1568 sol_thread_ops
.to_doc
= "Solaris threads and pthread support.";
1569 sol_thread_ops
.to_open
= sol_thread_open
;
1570 sol_thread_ops
.to_close
= 0;
1571 sol_thread_ops
.to_attach
= sol_thread_attach
;
1572 sol_thread_ops
.to_detach
= sol_thread_detach
;
1573 sol_thread_ops
.to_resume
= sol_thread_resume
;
1574 sol_thread_ops
.to_wait
= sol_thread_wait
;
1575 sol_thread_ops
.to_fetch_registers
= sol_thread_fetch_registers
;
1576 sol_thread_ops
.to_store_registers
= sol_thread_store_registers
;
1577 sol_thread_ops
.to_prepare_to_store
= sol_thread_prepare_to_store
;
1578 sol_thread_ops
.to_xfer_memory
= sol_thread_xfer_memory
;
1579 sol_thread_ops
.to_files_info
= sol_thread_files_info
;
1580 sol_thread_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1581 sol_thread_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1582 sol_thread_ops
.to_terminal_init
= terminal_init_inferior
;
1583 sol_thread_ops
.to_terminal_inferior
= terminal_inferior
;
1584 sol_thread_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1585 sol_thread_ops
.to_terminal_ours
= terminal_ours
;
1586 sol_thread_ops
.to_terminal_info
= child_terminal_info
;
1587 sol_thread_ops
.to_kill
= sol_thread_kill_inferior
;
1588 sol_thread_ops
.to_load
= 0;
1589 sol_thread_ops
.to_lookup_symbol
= 0;
1590 sol_thread_ops
.to_create_inferior
= sol_thread_create_inferior
;
1591 sol_thread_ops
.to_mourn_inferior
= sol_thread_mourn_inferior
;
1592 sol_thread_ops
.to_can_run
= sol_thread_can_run
;
1593 sol_thread_ops
.to_notice_signals
= sol_thread_notice_signals
;
1594 sol_thread_ops
.to_thread_alive
= sol_thread_alive
;
1595 sol_thread_ops
.to_pid_to_str
= solaris_pid_to_str
;
1596 sol_thread_ops
.to_find_new_threads
= sol_find_new_threads
;
1597 sol_thread_ops
.to_stop
= sol_thread_stop
;
1598 sol_thread_ops
.to_stratum
= process_stratum
;
1599 sol_thread_ops
.to_has_all_memory
= 1;
1600 sol_thread_ops
.to_has_memory
= 1;
1601 sol_thread_ops
.to_has_stack
= 1;
1602 sol_thread_ops
.to_has_registers
= 1;
1603 sol_thread_ops
.to_has_execution
= 1;
1604 sol_thread_ops
.to_has_thread_control
= tc_none
;
1605 sol_thread_ops
.to_sections
= 0;
1606 sol_thread_ops
.to_sections_end
= 0;
1607 sol_thread_ops
.to_magic
= OPS_MAGIC
;
1612 init_sol_core_ops (void)
1614 sol_core_ops
.to_shortname
= "solaris-core";
1615 sol_core_ops
.to_longname
= "Solaris core threads and pthread.";
1616 sol_core_ops
.to_doc
= "Solaris threads and pthread support for core files.";
1617 sol_core_ops
.to_open
= sol_core_open
;
1618 sol_core_ops
.to_close
= sol_core_close
;
1619 sol_core_ops
.to_attach
= sol_thread_attach
;
1620 sol_core_ops
.to_detach
= sol_core_detach
;
1621 /* sol_core_ops.to_resume = 0; */
1622 /* sol_core_ops.to_wait = 0; */
1623 sol_core_ops
.to_fetch_registers
= sol_thread_fetch_registers
;
1624 /* sol_core_ops.to_store_registers = 0; */
1625 /* sol_core_ops.to_prepare_to_store = 0; */
1626 sol_core_ops
.to_xfer_memory
= sol_thread_xfer_memory
;
1627 sol_core_ops
.to_files_info
= sol_core_files_info
;
1628 sol_core_ops
.to_insert_breakpoint
= ignore
;
1629 sol_core_ops
.to_remove_breakpoint
= ignore
;
1630 /* sol_core_ops.to_terminal_init = 0; */
1631 /* sol_core_ops.to_terminal_inferior = 0; */
1632 /* sol_core_ops.to_terminal_ours_for_output = 0; */
1633 /* sol_core_ops.to_terminal_ours = 0; */
1634 /* sol_core_ops.to_terminal_info = 0; */
1635 /* sol_core_ops.to_kill = 0; */
1636 /* sol_core_ops.to_load = 0; */
1637 /* sol_core_ops.to_lookup_symbol = 0; */
1638 sol_core_ops
.to_create_inferior
= sol_thread_create_inferior
;
1639 sol_core_ops
.to_stratum
= core_stratum
;
1640 sol_core_ops
.to_has_all_memory
= 0;
1641 sol_core_ops
.to_has_memory
= 1;
1642 sol_core_ops
.to_has_stack
= 1;
1643 sol_core_ops
.to_has_registers
= 1;
1644 sol_core_ops
.to_has_execution
= 0;
1645 sol_core_ops
.to_has_thread_control
= tc_none
;
1646 sol_core_ops
.to_thread_alive
= sol_thread_alive
;
1647 sol_core_ops
.to_pid_to_str
= solaris_pid_to_str
;
1648 /* On Solaris/x86, when debugging a threaded core file from process <n>,
1649 the following causes "info threads" to produce "procfs: couldn't find pid
1650 <n> in procinfo list" where <n> is the pid of the process that produced
1651 the core file. Disable it for now. */
1652 /* sol_core_ops.to_find_new_threads = sol_find_new_threads; */
1653 sol_core_ops
.to_sections
= 0;
1654 sol_core_ops
.to_sections_end
= 0;
1655 sol_core_ops
.to_magic
= OPS_MAGIC
;
1658 /* we suppress the call to add_target of core_ops in corelow because
1659 if there are two targets in the stratum core_stratum, find_core_target
1660 won't know which one to return. see corelow.c for an additonal
1661 comment on coreops_suppress_target. */
1662 int coreops_suppress_target
= 1;
1665 _initialize_sol_thread (void)
1669 init_sol_thread_ops ();
1670 init_sol_core_ops ();
1672 dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
);
1676 #define resolve(X) \
1677 if (!(p_##X = dlsym (dlhandle, #X))) \
1681 resolve (td_ta_new
);
1682 resolve (td_ta_delete
);
1684 resolve (td_ta_get_ph
);
1685 resolve (td_ta_get_nthreads
);
1686 resolve (td_ta_tsd_iter
);
1687 resolve (td_ta_thr_iter
);
1688 resolve (td_thr_validate
);
1689 resolve (td_thr_tsd
);
1690 resolve (td_thr_get_info
);
1691 resolve (td_thr_getfpregs
);
1692 resolve (td_thr_getxregsize
);
1693 resolve (td_thr_getxregs
);
1694 resolve (td_thr_sigsetmask
);
1695 resolve (td_thr_setprio
);
1696 resolve (td_thr_setsigpending
);
1697 resolve (td_thr_setfpregs
);
1698 resolve (td_thr_setxregs
);
1699 resolve (td_ta_map_id2thr
);
1700 resolve (td_ta_map_lwp2thr
);
1701 resolve (td_thr_getgregs
);
1702 resolve (td_thr_setgregs
);
1704 add_target (&sol_thread_ops
);
1706 procfs_suppress_run
= 1;
1708 add_cmd ("sol-threads", class_maintenance
, info_solthreads
,
1709 "Show info on Solaris user threads.\n", &maintenanceinfolist
);
1711 memcpy (&orig_core_ops
, &core_ops
, sizeof (struct target_ops
));
1712 memcpy (&core_ops
, &sol_core_ops
, sizeof (struct target_ops
));
1713 add_target (&core_ops
);
1715 /* Hook into new_objfile notification. */
1716 target_new_objfile_chain
= target_new_objfile_hook
;
1717 target_new_objfile_hook
= sol_thread_new_objfile
;
1722 fprintf_unfiltered (gdb_stderr
, "[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
1727 /* allow the user to debug non-threaded core files */
1728 add_target (&core_ops
);