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 (ptid_t ptid
);
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 char *td_err_string (td_err_e errcode
);
101 static char *td_state_string (td_thr_state_e statecode
);
102 static ptid_t
thread_to_lwp (ptid_t thread_id
, int default_lwp
);
103 static void sol_thread_resume (ptid_t ptid
, int step
, enum target_signal signo
);
104 static ptid_t
lwp_to_thread (ptid_t lwp
);
105 static int sol_thread_alive (ptid_t ptid
);
106 static void sol_core_close (int quitting
);
108 static void init_sol_thread_ops (void);
109 static void init_sol_core_ops (void);
111 /* Default definitions: These must be defined in tm.h
112 if they are to be shared with a process module such as procfs. */
114 #define GET_PID(ptid) ptid_get_pid (ptid)
115 #define GET_LWP(ptid) ptid_get_lwp (ptid)
116 #define GET_THREAD(ptid) ptid_get_tid (ptid)
118 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
119 #define is_thread(ptid) (GET_THREAD (ptid) != 0)
121 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
122 #define BUILD_THREAD(tid, pid) ptid_build (pid, 0, tid)
124 /* Pointers to routines from lithread_db resolved by dlopen() */
126 static void (*p_td_log
) (const int on_off
);
127 static td_err_e (*p_td_ta_new
) (const struct ps_prochandle
* ph_p
,
128 td_thragent_t
** ta_pp
);
129 static td_err_e (*p_td_ta_delete
) (td_thragent_t
* ta_p
);
130 static td_err_e (*p_td_init
) (void);
131 static td_err_e (*p_td_ta_get_ph
) (const td_thragent_t
* ta_p
,
132 struct ps_prochandle
** ph_pp
);
133 static td_err_e (*p_td_ta_get_nthreads
) (const td_thragent_t
* ta_p
,
135 static td_err_e (*p_td_ta_tsd_iter
) (const td_thragent_t
* ta_p
,
138 static td_err_e (*p_td_ta_thr_iter
) (const td_thragent_t
* ta_p
,
141 td_thr_state_e state
,
143 sigset_t
* ti_sigmask_p
,
144 unsigned ti_user_flags
);
145 static td_err_e (*p_td_thr_validate
) (const td_thrhandle_t
* th_p
);
146 static td_err_e (*p_td_thr_tsd
) (const td_thrhandle_t
* th_p
,
147 const thread_key_t key
,
149 static td_err_e (*p_td_thr_get_info
) (const td_thrhandle_t
* th_p
,
150 td_thrinfo_t
* ti_p
);
151 static td_err_e (*p_td_thr_getfpregs
) (const td_thrhandle_t
* th_p
,
152 prfpregset_t
* fpregset
);
153 static td_err_e (*p_td_thr_getxregsize
) (const td_thrhandle_t
* th_p
,
155 static td_err_e (*p_td_thr_getxregs
) (const td_thrhandle_t
* th_p
,
156 const caddr_t xregset
);
157 static td_err_e (*p_td_thr_sigsetmask
) (const td_thrhandle_t
* th_p
,
158 const sigset_t ti_sigmask
);
159 static td_err_e (*p_td_thr_setprio
) (const td_thrhandle_t
* th_p
,
161 static td_err_e (*p_td_thr_setsigpending
) (const td_thrhandle_t
* th_p
,
162 const uchar_t ti_pending_flag
,
163 const sigset_t ti_pending
);
164 static td_err_e (*p_td_thr_setfpregs
) (const td_thrhandle_t
* th_p
,
165 const prfpregset_t
* fpregset
);
166 static td_err_e (*p_td_thr_setxregs
) (const td_thrhandle_t
* th_p
,
167 const caddr_t xregset
);
168 static td_err_e (*p_td_ta_map_id2thr
) (const td_thragent_t
* ta_p
,
170 td_thrhandle_t
* th_p
);
171 static td_err_e (*p_td_ta_map_lwp2thr
) (const td_thragent_t
* ta_p
,
173 td_thrhandle_t
* th_p
);
174 static td_err_e (*p_td_thr_getgregs
) (const td_thrhandle_t
* th_p
,
176 static td_err_e (*p_td_thr_setgregs
) (const td_thrhandle_t
* th_p
,
177 const prgregset_t regset
);
183 td_err_string - Convert a thread_db error code to a string
187 char * td_err_string (errcode)
191 Return the thread_db error string associated with errcode. If errcode
192 is unknown, then return a message.
197 td_err_string (td_err_e errcode
)
199 static struct string_map
202 {TD_OK
, "generic \"call succeeded\""},
203 {TD_ERR
, "generic error."},
204 {TD_NOTHR
, "no thread can be found to satisfy query"},
205 {TD_NOSV
, "no synch. variable can be found to satisfy query"},
206 {TD_NOLWP
, "no lwp can be found to satisfy query"},
207 {TD_BADPH
, "invalid process handle"},
208 {TD_BADTH
, "invalid thread handle"},
209 {TD_BADSH
, "invalid synchronization handle"},
210 {TD_BADTA
, "invalid thread agent"},
211 {TD_BADKEY
, "invalid key"},
212 {TD_NOMSG
, "td_thr_event_getmsg() called when there was no message"},
213 {TD_NOFPREGS
, "FPU register set not available for given thread"},
214 {TD_NOLIBTHREAD
, "application not linked with libthread"},
215 {TD_NOEVENT
, "requested event is not supported"},
216 {TD_NOCAPAB
, "capability not available"},
217 {TD_DBERR
, "Debugger service failed"},
218 {TD_NOAPLIC
, "Operation not applicable to"},
219 {TD_NOTSD
, "No thread specific data for this thread"},
220 {TD_MALLOC
, "Malloc failed"},
221 {TD_PARTIALREG
, "Only part of register set was written/read"},
222 {TD_NOXREGS
, "X register set not available for given thread"}
224 const int td_err_size
= sizeof td_err_table
/ sizeof (struct string_map
);
228 for (i
= 0; i
< td_err_size
; i
++)
229 if (td_err_table
[i
].num
== errcode
)
230 return td_err_table
[i
].str
;
232 sprintf (buf
, "Unknown thread_db error code: %d", errcode
);
241 td_state_string - Convert a thread_db state code to a string
245 char * td_state_string (statecode)
249 Return the thread_db state string associated with statecode. If
250 statecode is unknown, then return a message.
255 td_state_string (td_thr_state_e statecode
)
257 static struct string_map
258 td_thr_state_table
[] =
260 {TD_THR_ANY_STATE
, "any state"},
261 {TD_THR_UNKNOWN
, "unknown"},
262 {TD_THR_STOPPED
, "stopped"},
264 {TD_THR_ACTIVE
, "active"},
265 {TD_THR_ZOMBIE
, "zombie"},
266 {TD_THR_SLEEP
, "sleep"},
267 {TD_THR_STOPPED_ASLEEP
, "stopped asleep"}
269 const int td_thr_state_table_size
= sizeof td_thr_state_table
/ sizeof (struct string_map
);
273 for (i
= 0; i
< td_thr_state_table_size
; i
++)
274 if (td_thr_state_table
[i
].num
== statecode
)
275 return td_thr_state_table
[i
].str
;
277 sprintf (buf
, "Unknown thread_db state code: %d", statecode
);
286 thread_to_lwp - Convert a Posix or Solaris thread id to a LWP id.
290 tpid_t thread_to_lwp (thread_id, default_lwp)
294 This function converts a Posix or Solaris thread id to a lightweight
295 process id. If thread_id is non-existent, that's an error. If it's
296 an inactive thread, then we return default_lwp.
300 This function probably shouldn't call error()...
305 thread_to_lwp (ptid_t thread_id
, int default_lwp
)
311 if (is_lwp (thread_id
))
312 return thread_id
; /* It's already an LWP id */
314 /* It's a thread. Convert to lwp */
316 val
= p_td_ta_map_id2thr (main_ta
, GET_THREAD (thread_id
), &th
);
318 return pid_to_ptid (-1); /* thread must have terminated */
319 else if (val
!= TD_OK
)
320 error ("thread_to_lwp: td_ta_map_id2thr %s", td_err_string (val
));
322 val
= p_td_thr_get_info (&th
, &ti
);
324 return pid_to_ptid (-1); /* thread must have terminated */
325 else if (val
!= TD_OK
)
326 error ("thread_to_lwp: td_thr_get_info: %s", td_err_string (val
));
328 if (ti
.ti_state
!= TD_THR_ACTIVE
)
330 if (default_lwp
!= -1)
331 return pid_to_ptid (default_lwp
);
332 error ("thread_to_lwp: thread state not active: %s",
333 td_state_string (ti
.ti_state
));
336 return BUILD_LWP (ti
.ti_lid
, PIDGET (thread_id
));
343 lwp_to_thread - Convert a LWP id to a Posix or Solaris thread id.
347 int lwp_to_thread (lwp_id)
351 This function converts a lightweight process id to a Posix or Solaris
352 thread id. If thread_id is non-existent, that's an error.
356 This function probably shouldn't call error()...
361 lwp_to_thread (ptid_t lwp
)
368 return lwp
; /* It's already a thread id */
370 /* It's an lwp. Convert it to a thread id. */
372 if (!sol_thread_alive (lwp
))
373 return pid_to_ptid (-1); /* defunct lwp */
375 val
= p_td_ta_map_lwp2thr (main_ta
, GET_LWP (lwp
), &th
);
377 return pid_to_ptid (-1); /* thread must have terminated */
378 else if (val
!= TD_OK
)
379 error ("lwp_to_thread: td_ta_map_lwp2thr: %s.", td_err_string (val
));
381 val
= p_td_thr_validate (&th
);
383 return lwp
; /* libthread doesn't know about it;
385 else if (val
!= TD_OK
)
386 error ("lwp_to_thread: td_thr_validate: %s.", td_err_string (val
));
388 val
= p_td_thr_get_info (&th
, &ti
);
390 return pid_to_ptid (-1); /* thread must have terminated */
391 else if (val
!= TD_OK
)
392 error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val
));
394 return BUILD_THREAD (ti
.ti_tid
, PIDGET (lwp
));
398 /* Most target vector functions from here on actually just pass through to
399 procfs.c, as they don't need to do anything specific for threads. */
404 sol_thread_open (char *arg
, int from_tty
)
406 procfs_ops
.to_open (arg
, from_tty
);
409 /* Attach to process PID, then initialize for debugging it
410 and wait for the trace-trap that results from attaching. */
413 sol_thread_attach (char *args
, int from_tty
)
415 procfs_ops
.to_attach (args
, from_tty
);
417 /* Must get symbols from solibs before libthread_db can run! */
418 SOLIB_ADD ((char *) 0, from_tty
, (struct target_ops
*) 0);
420 if (sol_thread_active
)
422 printf_filtered ("sol-thread active.\n");
423 main_ph
.ptid
= inferior_ptid
; /* Save for xfer_memory */
424 push_target (&sol_thread_ops
);
425 inferior_ptid
= lwp_to_thread (inferior_ptid
);
426 if (PIDGET (inferior_ptid
) == -1)
427 inferior_ptid
= main_ph
.ptid
;
429 add_thread (inferior_ptid
);
431 /* XXX - might want to iterate over all the threads and register them. */
434 /* Take a program previously attached to and detaches it.
435 The program resumes execution and will no longer stop
436 on signals, etc. We'd better not have left any breakpoints
437 in the program or it'll die when it hits one. For this
438 to work, it may be necessary for the process to have been
439 previously attached. It *might* work if the program was
440 started via the normal ptrace (PTRACE_TRACEME). */
443 sol_thread_detach (char *args
, int from_tty
)
445 inferior_ptid
= pid_to_ptid (PIDGET (main_ph
.ptid
));
446 unpush_target (&sol_thread_ops
);
447 procfs_ops
.to_detach (args
, from_tty
);
450 /* Resume execution of process PID. If STEP is nozero, then
451 just single step it. If SIGNAL is nonzero, restart it with that
452 signal activated. We may have to convert pid from a thread-id to an LWP id
456 sol_thread_resume (ptid_t ptid
, int step
, enum target_signal signo
)
458 struct cleanup
*old_chain
;
460 old_chain
= save_inferior_ptid ();
462 inferior_ptid
= thread_to_lwp (inferior_ptid
, PIDGET (main_ph
.ptid
));
463 if (PIDGET (inferior_ptid
) == -1)
464 inferior_ptid
= procfs_first_available ();
466 if (PIDGET (ptid
) != -1)
468 ptid_t save_ptid
= ptid
;
470 ptid
= thread_to_lwp (ptid
, -2);
471 if (PIDGET (ptid
) == -2) /* Inactive thread */
472 error ("This version of Solaris can't start inactive threads.");
473 if (info_verbose
&& PIDGET (ptid
) == -1)
474 warning ("Specified thread %ld seems to have terminated",
475 GET_THREAD (save_ptid
));
478 procfs_ops
.to_resume (ptid
, step
, signo
);
480 do_cleanups (old_chain
);
483 /* Wait for any threads to stop. We may have to convert PID from a thread id
484 to a LWP id, and vice versa on the way out. */
487 sol_thread_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
491 struct cleanup
*old_chain
;
493 save_ptid
= inferior_ptid
;
494 old_chain
= save_inferior_ptid ();
496 inferior_ptid
= thread_to_lwp (inferior_ptid
, PIDGET (main_ph
.ptid
));
497 if (PIDGET (inferior_ptid
) == -1)
498 inferior_ptid
= procfs_first_available ();
500 if (PIDGET (ptid
) != -1)
502 ptid_t save_ptid
= ptid
;
504 ptid
= thread_to_lwp (ptid
, -2);
505 if (PIDGET (ptid
) == -2) /* Inactive thread */
506 error ("This version of Solaris can't start inactive threads.");
507 if (info_verbose
&& PIDGET (ptid
) == -1)
508 warning ("Specified thread %ld seems to have terminated",
509 GET_THREAD (save_ptid
));
512 rtnval
= procfs_ops
.to_wait (ptid
, ourstatus
);
514 if (ourstatus
->kind
!= TARGET_WAITKIND_EXITED
)
516 /* Map the LWP of interest back to the appropriate thread ID */
517 rtnval
= lwp_to_thread (rtnval
);
518 if (PIDGET (rtnval
) == -1)
521 /* See if we have a new thread */
522 if (is_thread (rtnval
)
523 && !ptid_equal (rtnval
, save_ptid
)
524 && !in_thread_list (rtnval
))
526 printf_filtered ("[New %s]\n", target_pid_to_str (rtnval
));
531 /* During process initialization, we may get here without the thread package
532 being initialized, since that can only happen after we've found the shared
535 do_cleanups (old_chain
);
541 sol_thread_fetch_registers (int regno
)
544 td_thrhandle_t thandle
;
547 prfpregset_t fpregset
;
553 if (!is_thread (inferior_ptid
))
554 { /* LWP: pass the request on to procfs.c */
555 if (target_has_execution
)
556 procfs_ops
.to_fetch_registers (regno
);
558 orig_core_ops
.to_fetch_registers (regno
);
562 /* Solaris thread: convert inferior_ptid into a td_thrhandle_t */
564 thread
= GET_THREAD (inferior_ptid
);
567 error ("sol_thread_fetch_registers: thread == 0");
569 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
571 error ("sol_thread_fetch_registers: td_ta_map_id2thr: %s",
572 td_err_string (val
));
574 /* Get the integer regs */
576 val
= p_td_thr_getgregs (&thandle
, gregset
);
578 && val
!= TD_PARTIALREG
)
579 error ("sol_thread_fetch_registers: td_thr_getgregs %s",
580 td_err_string (val
));
582 /* For the sparc, TD_PARTIALREG means that only i0->i7, l0->l7, pc and sp
583 are saved (by a thread context switch). */
585 /* And, now the fp regs */
587 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
589 && val
!= TD_NOFPREGS
)
590 error ("sol_thread_fetch_registers: td_thr_getfpregs %s",
591 td_err_string (val
));
593 /* Note that we must call supply_{g fp}regset *after* calling the td routines
594 because the td routines call ps_lget* which affect the values stored in the
597 supply_gregset ((gdb_gregset_t
*) &gregset
);
598 supply_fpregset ((gdb_fpregset_t
*) &fpregset
);
601 /* thread_db doesn't seem to handle this right */
602 val
= td_thr_getxregsize (&thandle
, &xregsize
);
603 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
604 error ("sol_thread_fetch_registers: td_thr_getxregsize %s",
605 td_err_string (val
));
609 xregset
= alloca (xregsize
);
610 val
= td_thr_getxregs (&thandle
, xregset
);
612 error ("sol_thread_fetch_registers: td_thr_getxregs %s",
613 td_err_string (val
));
619 sol_thread_store_registers (int regno
)
622 td_thrhandle_t thandle
;
625 prfpregset_t fpregset
;
631 if (!is_thread (inferior_ptid
))
632 { /* LWP: pass the request on to procfs.c */
633 procfs_ops
.to_store_registers (regno
);
637 /* Solaris thread: convert inferior_ptid into a td_thrhandle_t */
639 thread
= GET_THREAD (inferior_ptid
);
641 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
643 error ("sol_thread_store_registers: td_ta_map_id2thr %s",
644 td_err_string (val
));
647 { /* Not writing all the regs */
648 /* save new register value */
649 char* old_value
= (char*) alloca (REGISTER_SIZE
);
650 memcpy (old_value
, ®isters
[REGISTER_BYTE (regno
)], REGISTER_SIZE
);
652 val
= p_td_thr_getgregs (&thandle
, gregset
);
654 error ("sol_thread_store_registers: td_thr_getgregs %s",
655 td_err_string (val
));
656 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
658 error ("sol_thread_store_registers: td_thr_getfpregs %s",
659 td_err_string (val
));
661 /* restore new register value */
662 memcpy (®isters
[REGISTER_BYTE (regno
)], old_value
, REGISTER_SIZE
);
665 /* thread_db doesn't seem to handle this right */
666 val
= td_thr_getxregsize (&thandle
, &xregsize
);
667 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
668 error ("sol_thread_store_registers: td_thr_getxregsize %s",
669 td_err_string (val
));
673 xregset
= alloca (xregsize
);
674 val
= td_thr_getxregs (&thandle
, xregset
);
676 error ("sol_thread_store_registers: td_thr_getxregs %s",
677 td_err_string (val
));
682 fill_gregset ((gdb_gregset_t
*) &gregset
, regno
);
683 fill_fpregset ((gdb_fpregset_t
*) &fpregset
, regno
);
685 val
= p_td_thr_setgregs (&thandle
, gregset
);
687 error ("sol_thread_store_registers: td_thr_setgregs %s",
688 td_err_string (val
));
689 val
= p_td_thr_setfpregs (&thandle
, &fpregset
);
691 error ("sol_thread_store_registers: td_thr_setfpregs %s",
692 td_err_string (val
));
695 /* thread_db doesn't seem to handle this right */
696 val
= td_thr_getxregsize (&thandle
, &xregsize
);
697 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
698 error ("sol_thread_store_registers: td_thr_getxregsize %s",
699 td_err_string (val
));
701 /* Should probably do something about writing the xregs here, but what are
706 /* Get ready to modify the registers array. On machines which store
707 individual registers, this doesn't need to do anything. On machines
708 which store all the registers in one fell swoop, this makes sure
709 that registers contains all the registers from the program being
713 sol_thread_prepare_to_store (void)
715 procfs_ops
.to_prepare_to_store ();
718 /* Transfer LEN bytes between GDB address MYADDR and target address
719 MEMADDR. If DOWRITE is non-zero, transfer them to the target,
720 otherwise transfer them from the target. TARGET is unused.
722 Returns the number of bytes transferred. */
725 sol_thread_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int dowrite
,
726 struct mem_attrib
*attrib
,
727 struct target_ops
*target
)
730 struct cleanup
*old_chain
;
732 old_chain
= save_inferior_ptid ();
734 if (is_thread (inferior_ptid
) || /* A thread */
735 !target_thread_alive (inferior_ptid
)) /* An lwp, but not alive */
736 inferior_ptid
= procfs_first_available (); /* Find any live lwp. */
737 /* Note: don't need to call switch_to_thread; we're just reading memory. */
739 if (target_has_execution
)
740 retval
= procfs_ops
.to_xfer_memory (memaddr
, myaddr
, len
,
741 dowrite
, attrib
, target
);
743 retval
= orig_core_ops
.to_xfer_memory (memaddr
, myaddr
, len
,
744 dowrite
, attrib
, target
);
746 do_cleanups (old_chain
);
751 /* Print status information about what we're accessing. */
754 sol_thread_files_info (struct target_ops
*ignore
)
756 procfs_ops
.to_files_info (ignore
);
760 sol_thread_kill_inferior (void)
762 procfs_ops
.to_kill ();
766 sol_thread_notice_signals (ptid_t ptid
)
768 procfs_ops
.to_notice_signals (pid_to_ptid (PIDGET (ptid
)));
771 /* Fork an inferior process, and start debugging it with /proc. */
774 sol_thread_create_inferior (char *exec_file
, char *allargs
, char **env
)
776 procfs_ops
.to_create_inferior (exec_file
, allargs
, env
);
778 if (sol_thread_active
&& !ptid_equal (inferior_ptid
, null_ptid
))
780 main_ph
.ptid
= inferior_ptid
; /* Save for xfer_memory */
782 push_target (&sol_thread_ops
);
784 inferior_ptid
= lwp_to_thread (inferior_ptid
);
785 if (PIDGET (inferior_ptid
) == -1)
786 inferior_ptid
= main_ph
.ptid
;
788 if (!in_thread_list (inferior_ptid
))
789 add_thread (inferior_ptid
);
793 /* This routine is called whenever a new symbol table is read in, or when all
794 symbol tables are removed. libthread_db can only be initialized when it
795 finds the right variables in libthread.so. Since it's a shared library,
796 those variables don't show up until the library gets mapped and the symbol
799 /* This new_objfile event is now managed by a chained function pointer.
800 * It is the callee's responsability to call the next client on the chain.
803 /* Saved pointer to previous owner of the new_objfile event. */
804 static void (*target_new_objfile_chain
) (struct objfile
*);
807 sol_thread_new_objfile (struct objfile
*objfile
)
813 sol_thread_active
= 0;
817 /* don't do anything if init failed to resolve the libthread_db library */
818 if (!procfs_suppress_run
)
821 /* Now, initialize the thread debugging library. This needs to be done after
822 the shared libraries are located because it needs information from the
823 user's thread library. */
828 warning ("sol_thread_new_objfile: td_init: %s", td_err_string (val
));
832 val
= p_td_ta_new (&main_ph
, &main_ta
);
833 if (val
== TD_NOLIBTHREAD
)
835 else if (val
!= TD_OK
)
837 warning ("sol_thread_new_objfile: td_ta_new: %s", td_err_string (val
));
841 sol_thread_active
= 1;
843 /* Call predecessor on chain, if any. */
844 if (target_new_objfile_chain
)
845 target_new_objfile_chain (objfile
);
848 /* Clean up after the inferior dies. */
851 sol_thread_mourn_inferior (void)
853 unpush_target (&sol_thread_ops
);
854 procfs_ops
.to_mourn_inferior ();
857 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
860 sol_thread_can_run (void)
862 return procfs_suppress_run
;
869 sol_thread_alive - test thread for "aliveness"
873 static bool sol_thread_alive (ptid_t ptid);
877 returns true if thread still active in inferior.
882 sol_thread_alive (ptid_t ptid
)
884 if (is_thread (ptid
)) /* non-kernel thread */
890 pid
= GET_THREAD (ptid
);
891 if ((val
= p_td_ta_map_id2thr (main_ta
, pid
, &th
)) != TD_OK
)
892 return 0; /* thread not found */
893 if ((val
= p_td_thr_validate (&th
)) != TD_OK
)
894 return 0; /* thread not valid */
895 return 1; /* known thread: return true */
898 /* kernel thread (LWP): let procfs test it */
900 if (target_has_execution
)
901 return procfs_ops
.to_thread_alive (ptid
);
903 return orig_core_ops
.to_thread_alive (ptid
);
908 sol_thread_stop (void)
910 procfs_ops
.to_stop ();
913 /* These routines implement the lower half of the thread_db interface. Ie: the
916 /* Various versions of <proc_service.h> have slightly
917 different function prototypes. In particular, we have
920 struct ps_prochandle * const struct ps_prochandle *
925 Which one you have depends on solaris version and what
926 patches you've applied. On the theory that there are
927 only two major variants, we have configure check the
928 prototype of ps_pdwrite (), and use that info to make
929 appropriate typedefs here. */
931 #ifdef PROC_SERVICE_IS_OLD
932 typedef const struct ps_prochandle
*gdb_ps_prochandle_t
;
933 typedef char *gdb_ps_read_buf_t
;
934 typedef char *gdb_ps_write_buf_t
;
935 typedef int gdb_ps_size_t
;
936 typedef paddr_t gdb_ps_addr_t
;
938 typedef struct ps_prochandle
*gdb_ps_prochandle_t
;
939 typedef void *gdb_ps_read_buf_t
;
940 typedef const void *gdb_ps_write_buf_t
;
941 typedef size_t gdb_ps_size_t
;
942 typedef psaddr_t gdb_ps_addr_t
;
946 /* The next four routines are called by thread_db to tell us to stop and stop
947 a particular process or lwp. Since GDB ensures that these are all stopped
948 by the time we call anything in thread_db, these routines need to do
954 ps_pstop (gdb_ps_prochandle_t ph
)
959 /* Process continue */
962 ps_pcontinue (gdb_ps_prochandle_t ph
)
970 ps_lstop (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
978 ps_lcontinue (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
983 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
986 ps_pglobal_lookup (gdb_ps_prochandle_t ph
, const char *ld_object_name
,
987 const char *ld_symbol_name
, gdb_ps_addr_t
* ld_symbol_addr
)
989 struct minimal_symbol
*ms
;
991 ms
= lookup_minimal_symbol (ld_symbol_name
, NULL
, NULL
);
996 *ld_symbol_addr
= SYMBOL_VALUE_ADDRESS (ms
);
1001 /* Common routine for reading and writing memory. */
1004 rw_common (int dowrite
, const struct ps_prochandle
*ph
, gdb_ps_addr_t addr
,
1005 char *buf
, int size
)
1007 struct cleanup
*old_chain
;
1009 old_chain
= save_inferior_ptid ();
1011 if (is_thread (inferior_ptid
) || /* A thread */
1012 !target_thread_alive (inferior_ptid
)) /* An lwp, but not alive */
1013 inferior_ptid
= procfs_first_available (); /* Find any live lwp. */
1014 /* Note: don't need to call switch_to_thread; we're just reading memory. */
1016 #if defined (__sparcv9)
1017 /* For Sparc64 cross Sparc32, make sure the address has not been
1018 accidentally sign-extended (or whatever) to beyond 32 bits. */
1019 if (bfd_get_arch_size (exec_bfd
) == 32)
1027 /* FIXME: passing 0 as attrib argument. */
1028 if (target_has_execution
)
1029 cc
= procfs_ops
.to_xfer_memory (addr
, buf
, size
,
1030 dowrite
, 0, &procfs_ops
);
1032 cc
= orig_core_ops
.to_xfer_memory (addr
, buf
, size
,
1033 dowrite
, 0, &core_ops
);
1038 print_sys_errmsg ("rw_common (): read", errno
);
1040 print_sys_errmsg ("rw_common (): write", errno
);
1042 do_cleanups (old_chain
);
1049 warning ("rw_common (): unable to read at addr 0x%lx",
1052 warning ("rw_common (): unable to write at addr 0x%lx",
1055 do_cleanups (old_chain
);
1064 do_cleanups (old_chain
);
1069 /* Copies SIZE bytes from target process .data segment to debugger memory. */
1072 ps_pdread (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
1073 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
1075 return rw_common (0, ph
, addr
, buf
, size
);
1078 /* Copies SIZE bytes from debugger memory .data segment to target process. */
1081 ps_pdwrite (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
1082 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
1084 return rw_common (1, ph
, addr
, (char *) buf
, size
);
1087 /* Copies SIZE bytes from target process .text segment to debugger memory. */
1090 ps_ptread (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
1091 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
1093 return rw_common (0, ph
, addr
, buf
, size
);
1096 /* Copies SIZE bytes from debugger memory .text segment to target process. */
1099 ps_ptwrite (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
1100 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
1102 return rw_common (1, ph
, addr
, (char *) buf
, size
);
1105 /* Get integer regs for LWP */
1108 ps_lgetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1109 prgregset_t gregset
)
1111 struct cleanup
*old_chain
;
1113 old_chain
= save_inferior_ptid ();
1115 inferior_ptid
= BUILD_LWP (lwpid
, PIDGET (inferior_ptid
));
1117 if (target_has_execution
)
1118 procfs_ops
.to_fetch_registers (-1);
1120 orig_core_ops
.to_fetch_registers (-1);
1121 fill_gregset ((gdb_gregset_t
*) gregset
, -1);
1123 do_cleanups (old_chain
);
1128 /* Set integer regs for LWP */
1131 ps_lsetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1132 const prgregset_t gregset
)
1134 struct cleanup
*old_chain
;
1136 old_chain
= save_inferior_ptid ();
1138 inferior_ptid
= BUILD_LWP (lwpid
, PIDGET (inferior_ptid
));
1140 supply_gregset ((gdb_gregset_t
*) gregset
);
1141 if (target_has_execution
)
1142 procfs_ops
.to_store_registers (-1);
1144 orig_core_ops
.to_store_registers (-1);
1146 do_cleanups (old_chain
);
1151 /* Log a message (sends to gdb_stderr). */
1154 ps_plog (const char *fmt
,...)
1158 va_start (args
, fmt
);
1160 vfprintf_filtered (gdb_stderr
, fmt
, args
);
1163 /* Get size of extra register set. Currently a noop. */
1166 ps_lgetxregsize (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, int *xregsize
)
1173 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1177 if (ioctl (lwp_fd
, PIOCGXREGSIZE
, ®size
))
1179 if (errno
== EINVAL
)
1180 return PS_NOFREGS
; /* XXX Wrong code, but this is the closest
1181 thing in proc_service.h */
1183 print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno
);
1191 /* Get extra register set. Currently a noop. */
1194 ps_lgetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
1200 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1204 if (ioctl (lwp_fd
, PIOCGXREG
, xregset
))
1206 print_sys_errmsg ("ps_lgetxregs (): PIOCGXREG", errno
);
1214 /* Set extra register set. Currently a noop. */
1217 ps_lsetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
1223 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1227 if (ioctl (lwp_fd
, PIOCSXREG
, xregset
))
1229 print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno
);
1237 /* Get floating-point regs for LWP */
1240 ps_lgetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1241 prfpregset_t
* fpregset
)
1243 struct cleanup
*old_chain
;
1245 old_chain
= save_inferior_ptid ();
1247 inferior_ptid
= BUILD_LWP (lwpid
, PIDGET (inferior_ptid
));
1249 if (target_has_execution
)
1250 procfs_ops
.to_fetch_registers (-1);
1252 orig_core_ops
.to_fetch_registers (-1);
1253 fill_fpregset ((gdb_fpregset_t
*) fpregset
, -1);
1255 do_cleanups (old_chain
);
1260 /* Set floating-point regs for LWP */
1263 ps_lsetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1264 const prfpregset_t
* fpregset
)
1266 struct cleanup
*old_chain
;
1268 old_chain
= save_inferior_ptid ();
1270 inferior_ptid
= BUILD_LWP (lwpid
, PIDGET (inferior_ptid
));
1272 supply_fpregset ((gdb_fpregset_t
*) fpregset
);
1273 if (target_has_execution
)
1274 procfs_ops
.to_store_registers (-1);
1276 orig_core_ops
.to_store_registers (-1);
1278 do_cleanups (old_chain
);
1283 #ifdef PR_MODEL_LP64
1284 /* Identify process as 32-bit or 64-bit.
1285 At the moment I'm using bfd to do this.
1286 There might be a more solaris-specific (eg. procfs) method,
1287 but this ought to work. */
1290 ps_pdmodel (gdb_ps_prochandle_t ph
, int *data_model
)
1293 *data_model
= PR_MODEL_UNKNOWN
;
1294 else if (bfd_get_arch_size (exec_bfd
) == 32)
1295 *data_model
= PR_MODEL_ILP32
;
1297 *data_model
= PR_MODEL_LP64
;
1301 #endif /* PR_MODEL_LP64 */
1303 #ifdef TM_I386SOL2_H
1305 /* Reads the local descriptor table of a LWP. */
1308 ps_lgetLDT (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1311 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c */
1312 extern struct ssd
*procfs_find_LDT_entry (ptid_t
);
1315 /* FIXME: can't I get the process ID from the prochandle or something?
1318 if (PIDGET (inferior_ptid
) <= 0 || lwpid
<= 0)
1321 ret
= procfs_find_LDT_entry (BUILD_LWP (lwpid
, PIDGET (inferior_ptid
)));
1324 memcpy (pldt
, ret
, sizeof (struct ssd
));
1327 else /* LDT not found. */
1330 #endif /* TM_I386SOL2_H */
1332 /* Convert a pid to printable form. */
1335 solaris_pid_to_str (ptid_t ptid
)
1337 static char buf
[100];
1339 /* in case init failed to resolve the libthread_db library */
1340 if (!procfs_suppress_run
)
1341 return procfs_pid_to_str (ptid
);
1343 if (is_thread (ptid
))
1347 lwp
= thread_to_lwp (ptid
, -2);
1349 if (PIDGET (lwp
) == -1)
1350 sprintf (buf
, "Thread %ld (defunct)", GET_THREAD (ptid
));
1351 else if (PIDGET (lwp
) != -2)
1352 sprintf (buf
, "Thread %ld (LWP %ld)", GET_THREAD (ptid
), GET_LWP (lwp
));
1354 sprintf (buf
, "Thread %ld ", GET_THREAD (ptid
));
1356 else if (GET_LWP (ptid
) != 0)
1357 sprintf (buf
, "LWP %ld ", GET_LWP (ptid
));
1359 sprintf (buf
, "process %d ", PIDGET (ptid
));
1365 /* Worker bee for find_new_threads
1366 Callback function that gets called once per USER thread (i.e., not
1370 sol_find_new_threads_callback (const td_thrhandle_t
*th
, void *ignored
)
1376 if ((retval
= p_td_thr_get_info (th
, &ti
)) != TD_OK
)
1380 ptid
= BUILD_THREAD (ti
.ti_tid
, PIDGET (inferior_ptid
));
1381 if (!in_thread_list (ptid
))
1388 sol_find_new_threads (void)
1390 /* don't do anything if init failed to resolve the libthread_db library */
1391 if (!procfs_suppress_run
)
1394 if (PIDGET (inferior_ptid
) == -1)
1396 printf_filtered ("No process.\n");
1399 procfs_ops
.to_find_new_threads (); /* first find new kernel threads */
1400 p_td_ta_thr_iter (main_ta
, sol_find_new_threads_callback
, (void *) 0,
1401 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1402 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1406 sol_core_open (char *filename
, int from_tty
)
1408 orig_core_ops
.to_open (filename
, from_tty
);
1412 sol_core_close (int quitting
)
1414 orig_core_ops
.to_close (quitting
);
1418 sol_core_detach (char *args
, int from_tty
)
1420 unpush_target (&core_ops
);
1421 orig_core_ops
.to_detach (args
, from_tty
);
1425 sol_core_files_info (struct target_ops
*t
)
1427 orig_core_ops
.to_files_info (t
);
1430 /* Worker bee for info sol-thread command. This is a callback function that
1431 gets called once for each Solaris thread (ie. not kernel thread) in the
1432 inferior. Print anything interesting that we can think of. */
1435 info_cb (const td_thrhandle_t
*th
, void *s
)
1440 if ((ret
= p_td_thr_get_info (th
, &ti
)) == TD_OK
)
1442 printf_filtered ("%s thread #%d, lwp %d, ",
1443 ti
.ti_type
== TD_THR_SYSTEM
? "system" : "user ",
1444 ti
.ti_tid
, ti
.ti_lid
);
1445 switch (ti
.ti_state
)
1448 case TD_THR_UNKNOWN
:
1449 printf_filtered ("<unknown state>");
1451 case TD_THR_STOPPED
:
1452 printf_filtered ("(stopped)");
1455 printf_filtered ("(run) ");
1458 printf_filtered ("(active) ");
1461 printf_filtered ("(zombie) ");
1464 printf_filtered ("(asleep) ");
1466 case TD_THR_STOPPED_ASLEEP
:
1467 printf_filtered ("(stopped asleep)");
1470 /* Print thr_create start function: */
1471 if (ti
.ti_startfunc
!= 0)
1473 struct minimal_symbol
*msym
;
1474 msym
= lookup_minimal_symbol_by_pc (ti
.ti_startfunc
);
1476 printf_filtered (" startfunc: %s\n", SYMBOL_NAME (msym
));
1478 printf_filtered (" startfunc: 0x%s\n", paddr (ti
.ti_startfunc
));
1481 /* If thread is asleep, print function that went to sleep: */
1482 if (ti
.ti_state
== TD_THR_SLEEP
)
1484 struct minimal_symbol
*msym
;
1485 msym
= lookup_minimal_symbol_by_pc (ti
.ti_pc
);
1487 printf_filtered (" - Sleep func: %s\n", SYMBOL_NAME (msym
));
1489 printf_filtered (" - Sleep func: 0x%s\n", paddr (ti
.ti_startfunc
));
1492 /* Wrap up line, if necessary */
1493 if (ti
.ti_state
!= TD_THR_SLEEP
&& ti
.ti_startfunc
== 0)
1494 printf_filtered ("\n"); /* don't you hate counting newlines? */
1497 warning ("info sol-thread: failed to get info for thread.");
1502 /* List some state about each Solaris user thread in the inferior. */
1505 info_solthreads (char *args
, int from_tty
)
1507 p_td_ta_thr_iter (main_ta
, info_cb
, args
,
1508 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1509 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1513 ignore (CORE_ADDR addr
, char *contents
)
1520 init_sol_thread_ops (void)
1522 sol_thread_ops
.to_shortname
= "solaris-threads";
1523 sol_thread_ops
.to_longname
= "Solaris threads and pthread.";
1524 sol_thread_ops
.to_doc
= "Solaris threads and pthread support.";
1525 sol_thread_ops
.to_open
= sol_thread_open
;
1526 sol_thread_ops
.to_close
= 0;
1527 sol_thread_ops
.to_attach
= sol_thread_attach
;
1528 sol_thread_ops
.to_detach
= sol_thread_detach
;
1529 sol_thread_ops
.to_resume
= sol_thread_resume
;
1530 sol_thread_ops
.to_wait
= sol_thread_wait
;
1531 sol_thread_ops
.to_fetch_registers
= sol_thread_fetch_registers
;
1532 sol_thread_ops
.to_store_registers
= sol_thread_store_registers
;
1533 sol_thread_ops
.to_prepare_to_store
= sol_thread_prepare_to_store
;
1534 sol_thread_ops
.to_xfer_memory
= sol_thread_xfer_memory
;
1535 sol_thread_ops
.to_files_info
= sol_thread_files_info
;
1536 sol_thread_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1537 sol_thread_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1538 sol_thread_ops
.to_terminal_init
= terminal_init_inferior
;
1539 sol_thread_ops
.to_terminal_inferior
= terminal_inferior
;
1540 sol_thread_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1541 sol_thread_ops
.to_terminal_ours
= terminal_ours
;
1542 sol_thread_ops
.to_terminal_info
= child_terminal_info
;
1543 sol_thread_ops
.to_kill
= sol_thread_kill_inferior
;
1544 sol_thread_ops
.to_load
= 0;
1545 sol_thread_ops
.to_lookup_symbol
= 0;
1546 sol_thread_ops
.to_create_inferior
= sol_thread_create_inferior
;
1547 sol_thread_ops
.to_mourn_inferior
= sol_thread_mourn_inferior
;
1548 sol_thread_ops
.to_can_run
= sol_thread_can_run
;
1549 sol_thread_ops
.to_notice_signals
= sol_thread_notice_signals
;
1550 sol_thread_ops
.to_thread_alive
= sol_thread_alive
;
1551 sol_thread_ops
.to_pid_to_str
= solaris_pid_to_str
;
1552 sol_thread_ops
.to_find_new_threads
= sol_find_new_threads
;
1553 sol_thread_ops
.to_stop
= sol_thread_stop
;
1554 sol_thread_ops
.to_stratum
= process_stratum
;
1555 sol_thread_ops
.to_has_all_memory
= 1;
1556 sol_thread_ops
.to_has_memory
= 1;
1557 sol_thread_ops
.to_has_stack
= 1;
1558 sol_thread_ops
.to_has_registers
= 1;
1559 sol_thread_ops
.to_has_execution
= 1;
1560 sol_thread_ops
.to_has_thread_control
= tc_none
;
1561 sol_thread_ops
.to_sections
= 0;
1562 sol_thread_ops
.to_sections_end
= 0;
1563 sol_thread_ops
.to_magic
= OPS_MAGIC
;
1568 init_sol_core_ops (void)
1570 sol_core_ops
.to_shortname
= "solaris-core";
1571 sol_core_ops
.to_longname
= "Solaris core threads and pthread.";
1572 sol_core_ops
.to_doc
= "Solaris threads and pthread support for core files.";
1573 sol_core_ops
.to_open
= sol_core_open
;
1574 sol_core_ops
.to_close
= sol_core_close
;
1575 sol_core_ops
.to_attach
= sol_thread_attach
;
1576 sol_core_ops
.to_detach
= sol_core_detach
;
1577 /* sol_core_ops.to_resume = 0; */
1578 /* sol_core_ops.to_wait = 0; */
1579 sol_core_ops
.to_fetch_registers
= sol_thread_fetch_registers
;
1580 /* sol_core_ops.to_store_registers = 0; */
1581 /* sol_core_ops.to_prepare_to_store = 0; */
1582 sol_core_ops
.to_xfer_memory
= sol_thread_xfer_memory
;
1583 sol_core_ops
.to_files_info
= sol_core_files_info
;
1584 sol_core_ops
.to_insert_breakpoint
= ignore
;
1585 sol_core_ops
.to_remove_breakpoint
= ignore
;
1586 /* sol_core_ops.to_terminal_init = 0; */
1587 /* sol_core_ops.to_terminal_inferior = 0; */
1588 /* sol_core_ops.to_terminal_ours_for_output = 0; */
1589 /* sol_core_ops.to_terminal_ours = 0; */
1590 /* sol_core_ops.to_terminal_info = 0; */
1591 /* sol_core_ops.to_kill = 0; */
1592 /* sol_core_ops.to_load = 0; */
1593 /* sol_core_ops.to_lookup_symbol = 0; */
1594 sol_core_ops
.to_create_inferior
= sol_thread_create_inferior
;
1595 sol_core_ops
.to_stratum
= core_stratum
;
1596 sol_core_ops
.to_has_all_memory
= 0;
1597 sol_core_ops
.to_has_memory
= 1;
1598 sol_core_ops
.to_has_stack
= 1;
1599 sol_core_ops
.to_has_registers
= 1;
1600 sol_core_ops
.to_has_execution
= 0;
1601 sol_core_ops
.to_has_thread_control
= tc_none
;
1602 sol_core_ops
.to_thread_alive
= sol_thread_alive
;
1603 sol_core_ops
.to_pid_to_str
= solaris_pid_to_str
;
1604 /* On Solaris/x86, when debugging a threaded core file from process <n>,
1605 the following causes "info threads" to produce "procfs: couldn't find pid
1606 <n> in procinfo list" where <n> is the pid of the process that produced
1607 the core file. Disable it for now. */
1608 /* sol_core_ops.to_find_new_threads = sol_find_new_threads; */
1609 sol_core_ops
.to_sections
= 0;
1610 sol_core_ops
.to_sections_end
= 0;
1611 sol_core_ops
.to_magic
= OPS_MAGIC
;
1614 /* we suppress the call to add_target of core_ops in corelow because
1615 if there are two targets in the stratum core_stratum, find_core_target
1616 won't know which one to return. see corelow.c for an additonal
1617 comment on coreops_suppress_target. */
1618 int coreops_suppress_target
= 1;
1621 _initialize_sol_thread (void)
1625 init_sol_thread_ops ();
1626 init_sol_core_ops ();
1628 dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
);
1632 #define resolve(X) \
1633 if (!(p_##X = dlsym (dlhandle, #X))) \
1637 resolve (td_ta_new
);
1638 resolve (td_ta_delete
);
1640 resolve (td_ta_get_ph
);
1641 resolve (td_ta_get_nthreads
);
1642 resolve (td_ta_tsd_iter
);
1643 resolve (td_ta_thr_iter
);
1644 resolve (td_thr_validate
);
1645 resolve (td_thr_tsd
);
1646 resolve (td_thr_get_info
);
1647 resolve (td_thr_getfpregs
);
1648 resolve (td_thr_getxregsize
);
1649 resolve (td_thr_getxregs
);
1650 resolve (td_thr_sigsetmask
);
1651 resolve (td_thr_setprio
);
1652 resolve (td_thr_setsigpending
);
1653 resolve (td_thr_setfpregs
);
1654 resolve (td_thr_setxregs
);
1655 resolve (td_ta_map_id2thr
);
1656 resolve (td_ta_map_lwp2thr
);
1657 resolve (td_thr_getgregs
);
1658 resolve (td_thr_setgregs
);
1660 add_target (&sol_thread_ops
);
1662 procfs_suppress_run
= 1;
1664 add_cmd ("sol-threads", class_maintenance
, info_solthreads
,
1665 "Show info on Solaris user threads.\n", &maintenanceinfolist
);
1667 memcpy (&orig_core_ops
, &core_ops
, sizeof (struct target_ops
));
1668 memcpy (&core_ops
, &sol_core_ops
, sizeof (struct target_ops
));
1669 add_target (&core_ops
);
1671 /* Hook into new_objfile notification. */
1672 target_new_objfile_chain
= target_new_objfile_hook
;
1673 target_new_objfile_hook
= sol_thread_new_objfile
;
1678 fprintf_unfiltered (gdb_stderr
, "[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
1683 /* allow the user to debug non-threaded core files */
1684 add_target (&core_ops
);