1 /* Low level interface for debugging Solaris threads for GDB, the GNU debugger.
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
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"
65 #include "gdb_string.h"
67 extern struct target_ops sol_thread_ops
; /* Forward declaration */
68 extern struct target_ops sol_core_ops
; /* Forward declaration */
70 /* place to store core_ops before we overwrite it */
71 static struct target_ops orig_core_ops
;
73 struct target_ops sol_thread_ops
;
74 struct target_ops sol_core_ops
;
76 extern int procfs_suppress_run
;
77 extern struct target_ops procfs_ops
; /* target vector for procfs.c */
78 extern struct target_ops core_ops
; /* target vector for corelow.c */
79 extern char *procfs_pid_to_str (ptid_t ptid
);
81 /* Prototypes for supply_gregset etc. */
84 /* This struct is defined by us, but mainly used for the proc_service interface.
85 We don't have much use for it, except as a handy place to get a real pid
86 for memory accesses. */
99 static struct ps_prochandle main_ph
;
100 static td_thragent_t
*main_ta
;
101 static int sol_thread_active
= 0;
103 static char *td_err_string (td_err_e errcode
);
104 static char *td_state_string (td_thr_state_e statecode
);
105 static ptid_t
thread_to_lwp (ptid_t thread_id
, int default_lwp
);
106 static void sol_thread_resume (ptid_t ptid
, int step
, enum target_signal signo
);
107 static ptid_t
lwp_to_thread (ptid_t lwp
);
108 static int sol_thread_alive (ptid_t ptid
);
109 static void sol_core_close (int quitting
);
111 static void init_sol_thread_ops (void);
112 static void init_sol_core_ops (void);
114 /* Default definitions: These must be defined in tm.h
115 if they are to be shared with a process module such as procfs. */
117 #define GET_PID(ptid) ptid_get_pid (ptid)
118 #define GET_LWP(ptid) ptid_get_lwp (ptid)
119 #define GET_THREAD(ptid) ptid_get_tid (ptid)
121 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
122 #define is_thread(ptid) (GET_THREAD (ptid) != 0)
124 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
125 #define BUILD_THREAD(tid, pid) ptid_build (pid, 0, tid)
127 /* Pointers to routines from lithread_db resolved by dlopen() */
129 static void (*p_td_log
) (const int on_off
);
130 static td_err_e (*p_td_ta_new
) (const struct ps_prochandle
* ph_p
,
131 td_thragent_t
** ta_pp
);
132 static td_err_e (*p_td_ta_delete
) (td_thragent_t
* ta_p
);
133 static td_err_e (*p_td_init
) (void);
134 static td_err_e (*p_td_ta_get_ph
) (const td_thragent_t
* ta_p
,
135 struct ps_prochandle
** ph_pp
);
136 static td_err_e (*p_td_ta_get_nthreads
) (const td_thragent_t
* ta_p
,
138 static td_err_e (*p_td_ta_tsd_iter
) (const td_thragent_t
* ta_p
,
141 static td_err_e (*p_td_ta_thr_iter
) (const td_thragent_t
* ta_p
,
144 td_thr_state_e state
,
146 sigset_t
* ti_sigmask_p
,
147 unsigned ti_user_flags
);
148 static td_err_e (*p_td_thr_validate
) (const td_thrhandle_t
* th_p
);
149 static td_err_e (*p_td_thr_tsd
) (const td_thrhandle_t
* th_p
,
150 const thread_key_t key
,
152 static td_err_e (*p_td_thr_get_info
) (const td_thrhandle_t
* th_p
,
153 td_thrinfo_t
* ti_p
);
154 static td_err_e (*p_td_thr_getfpregs
) (const td_thrhandle_t
* th_p
,
155 prfpregset_t
* fpregset
);
156 static td_err_e (*p_td_thr_getxregsize
) (const td_thrhandle_t
* th_p
,
158 static td_err_e (*p_td_thr_getxregs
) (const td_thrhandle_t
* th_p
,
159 const caddr_t xregset
);
160 static td_err_e (*p_td_thr_sigsetmask
) (const td_thrhandle_t
* th_p
,
161 const sigset_t ti_sigmask
);
162 static td_err_e (*p_td_thr_setprio
) (const td_thrhandle_t
* th_p
,
164 static td_err_e (*p_td_thr_setsigpending
) (const td_thrhandle_t
* th_p
,
165 const uchar_t ti_pending_flag
,
166 const sigset_t ti_pending
);
167 static td_err_e (*p_td_thr_setfpregs
) (const td_thrhandle_t
* th_p
,
168 const prfpregset_t
* fpregset
);
169 static td_err_e (*p_td_thr_setxregs
) (const td_thrhandle_t
* th_p
,
170 const caddr_t xregset
);
171 static td_err_e (*p_td_ta_map_id2thr
) (const td_thragent_t
* ta_p
,
173 td_thrhandle_t
* th_p
);
174 static td_err_e (*p_td_ta_map_lwp2thr
) (const td_thragent_t
* ta_p
,
176 td_thrhandle_t
* th_p
);
177 static td_err_e (*p_td_thr_getgregs
) (const td_thrhandle_t
* th_p
,
179 static td_err_e (*p_td_thr_setgregs
) (const td_thrhandle_t
* th_p
,
180 const prgregset_t regset
);
186 td_err_string - Convert a thread_db error code to a string
190 char * td_err_string (errcode)
194 Return the thread_db error string associated with errcode. If errcode
195 is unknown, then return a message.
200 td_err_string (td_err_e errcode
)
202 static struct string_map
205 {TD_OK
, "generic \"call succeeded\""},
206 {TD_ERR
, "generic error."},
207 {TD_NOTHR
, "no thread can be found to satisfy query"},
208 {TD_NOSV
, "no synch. variable can be found to satisfy query"},
209 {TD_NOLWP
, "no lwp can be found to satisfy query"},
210 {TD_BADPH
, "invalid process handle"},
211 {TD_BADTH
, "invalid thread handle"},
212 {TD_BADSH
, "invalid synchronization handle"},
213 {TD_BADTA
, "invalid thread agent"},
214 {TD_BADKEY
, "invalid key"},
215 {TD_NOMSG
, "td_thr_event_getmsg() called when there was no message"},
216 {TD_NOFPREGS
, "FPU register set not available for given thread"},
217 {TD_NOLIBTHREAD
, "application not linked with libthread"},
218 {TD_NOEVENT
, "requested event is not supported"},
219 {TD_NOCAPAB
, "capability not available"},
220 {TD_DBERR
, "Debugger service failed"},
221 {TD_NOAPLIC
, "Operation not applicable to"},
222 {TD_NOTSD
, "No thread specific data for this thread"},
223 {TD_MALLOC
, "Malloc failed"},
224 {TD_PARTIALREG
, "Only part of register set was written/read"},
225 {TD_NOXREGS
, "X register set not available for given thread"}
227 const int td_err_size
= sizeof td_err_table
/ sizeof (struct string_map
);
231 for (i
= 0; i
< td_err_size
; i
++)
232 if (td_err_table
[i
].num
== errcode
)
233 return td_err_table
[i
].str
;
235 sprintf (buf
, "Unknown thread_db error code: %d", errcode
);
244 td_state_string - Convert a thread_db state code to a string
248 char * td_state_string (statecode)
252 Return the thread_db state string associated with statecode. If
253 statecode is unknown, then return a message.
258 td_state_string (td_thr_state_e statecode
)
260 static struct string_map
261 td_thr_state_table
[] =
263 {TD_THR_ANY_STATE
, "any state"},
264 {TD_THR_UNKNOWN
, "unknown"},
265 {TD_THR_STOPPED
, "stopped"},
267 {TD_THR_ACTIVE
, "active"},
268 {TD_THR_ZOMBIE
, "zombie"},
269 {TD_THR_SLEEP
, "sleep"},
270 {TD_THR_STOPPED_ASLEEP
, "stopped asleep"}
272 const int td_thr_state_table_size
= sizeof td_thr_state_table
/ sizeof (struct string_map
);
276 for (i
= 0; i
< td_thr_state_table_size
; i
++)
277 if (td_thr_state_table
[i
].num
== statecode
)
278 return td_thr_state_table
[i
].str
;
280 sprintf (buf
, "Unknown thread_db state code: %d", statecode
);
289 thread_to_lwp - Convert a Posix or Solaris thread id to a LWP id.
293 tpid_t thread_to_lwp (thread_id, default_lwp)
297 This function converts a Posix or Solaris thread id to a lightweight
298 process id. If thread_id is non-existent, that's an error. If it's
299 an inactive thread, then we return default_lwp.
303 This function probably shouldn't call error()...
308 thread_to_lwp (ptid_t thread_id
, int default_lwp
)
314 if (is_lwp (thread_id
))
315 return thread_id
; /* It's already an LWP id */
317 /* It's a thread. Convert to lwp */
319 val
= p_td_ta_map_id2thr (main_ta
, GET_THREAD (thread_id
), &th
);
321 return pid_to_ptid (-1); /* thread must have terminated */
322 else if (val
!= TD_OK
)
323 error ("thread_to_lwp: td_ta_map_id2thr %s", td_err_string (val
));
325 val
= p_td_thr_get_info (&th
, &ti
);
327 return pid_to_ptid (-1); /* thread must have terminated */
328 else if (val
!= TD_OK
)
329 error ("thread_to_lwp: td_thr_get_info: %s", td_err_string (val
));
331 if (ti
.ti_state
!= TD_THR_ACTIVE
)
333 if (default_lwp
!= -1)
334 return pid_to_ptid (default_lwp
);
335 error ("thread_to_lwp: thread state not active: %s",
336 td_state_string (ti
.ti_state
));
339 return BUILD_LWP (ti
.ti_lid
, PIDGET (thread_id
));
346 lwp_to_thread - Convert a LWP id to a Posix or Solaris thread id.
350 int lwp_to_thread (lwp_id)
354 This function converts a lightweight process id to a Posix or Solaris
355 thread id. If thread_id is non-existent, that's an error.
359 This function probably shouldn't call error()...
364 lwp_to_thread (ptid_t lwp
)
371 return lwp
; /* It's already a thread id */
373 /* It's an lwp. Convert it to a thread id. */
375 if (!sol_thread_alive (lwp
))
376 return pid_to_ptid (-1); /* defunct lwp */
378 val
= p_td_ta_map_lwp2thr (main_ta
, GET_LWP (lwp
), &th
);
380 return pid_to_ptid (-1); /* thread must have terminated */
381 else if (val
!= TD_OK
)
382 error ("lwp_to_thread: td_ta_map_lwp2thr: %s.", td_err_string (val
));
384 val
= p_td_thr_validate (&th
);
386 return lwp
; /* libthread doesn't know about it;
388 else if (val
!= TD_OK
)
389 error ("lwp_to_thread: td_thr_validate: %s.", td_err_string (val
));
391 val
= p_td_thr_get_info (&th
, &ti
);
393 return pid_to_ptid (-1); /* thread must have terminated */
394 else if (val
!= TD_OK
)
395 error ("lwp_to_thread: td_thr_get_info: %s.", td_err_string (val
));
397 return BUILD_THREAD (ti
.ti_tid
, PIDGET (lwp
));
401 /* Most target vector functions from here on actually just pass through to
402 procfs.c, as they don't need to do anything specific for threads. */
407 sol_thread_open (char *arg
, int from_tty
)
409 procfs_ops
.to_open (arg
, from_tty
);
412 /* Attach to process PID, then initialize for debugging it
413 and wait for the trace-trap that results from attaching. */
416 sol_thread_attach (char *args
, int from_tty
)
418 procfs_ops
.to_attach (args
, from_tty
);
420 /* Must get symbols from solibs before libthread_db can run! */
421 SOLIB_ADD ((char *) 0, from_tty
, (struct target_ops
*) 0, auto_solib_add
);
423 if (sol_thread_active
)
425 printf_filtered ("sol-thread active.\n");
426 main_ph
.ptid
= inferior_ptid
; /* Save for xfer_memory */
427 push_target (&sol_thread_ops
);
428 inferior_ptid
= lwp_to_thread (inferior_ptid
);
429 if (PIDGET (inferior_ptid
) == -1)
430 inferior_ptid
= main_ph
.ptid
;
432 add_thread (inferior_ptid
);
434 /* XXX - might want to iterate over all the threads and register them. */
437 /* Take a program previously attached to and detaches it.
438 The program resumes execution and will no longer stop
439 on signals, etc. We'd better not have left any breakpoints
440 in the program or it'll die when it hits one. For this
441 to work, it may be necessary for the process to have been
442 previously attached. It *might* work if the program was
443 started via the normal ptrace (PTRACE_TRACEME). */
446 sol_thread_detach (char *args
, int from_tty
)
448 inferior_ptid
= pid_to_ptid (PIDGET (main_ph
.ptid
));
449 unpush_target (&sol_thread_ops
);
450 procfs_ops
.to_detach (args
, from_tty
);
453 /* Resume execution of process PID. If STEP is nozero, then
454 just single step it. If SIGNAL is nonzero, restart it with that
455 signal activated. We may have to convert pid from a thread-id to an LWP id
459 sol_thread_resume (ptid_t ptid
, int step
, enum target_signal signo
)
461 struct cleanup
*old_chain
;
463 old_chain
= save_inferior_ptid ();
465 inferior_ptid
= thread_to_lwp (inferior_ptid
, PIDGET (main_ph
.ptid
));
466 if (PIDGET (inferior_ptid
) == -1)
467 inferior_ptid
= procfs_first_available ();
469 if (PIDGET (ptid
) != -1)
471 ptid_t save_ptid
= ptid
;
473 ptid
= thread_to_lwp (ptid
, -2);
474 if (PIDGET (ptid
) == -2) /* Inactive thread */
475 error ("This version of Solaris can't start inactive threads.");
476 if (info_verbose
&& PIDGET (ptid
) == -1)
477 warning ("Specified thread %ld seems to have terminated",
478 GET_THREAD (save_ptid
));
481 procfs_ops
.to_resume (ptid
, step
, signo
);
483 do_cleanups (old_chain
);
486 /* Wait for any threads to stop. We may have to convert PID from a thread id
487 to a LWP id, and vice versa on the way out. */
490 sol_thread_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
494 struct cleanup
*old_chain
;
496 save_ptid
= inferior_ptid
;
497 old_chain
= save_inferior_ptid ();
499 inferior_ptid
= thread_to_lwp (inferior_ptid
, PIDGET (main_ph
.ptid
));
500 if (PIDGET (inferior_ptid
) == -1)
501 inferior_ptid
= procfs_first_available ();
503 if (PIDGET (ptid
) != -1)
505 ptid_t save_ptid
= ptid
;
507 ptid
= thread_to_lwp (ptid
, -2);
508 if (PIDGET (ptid
) == -2) /* Inactive thread */
509 error ("This version of Solaris can't start inactive threads.");
510 if (info_verbose
&& PIDGET (ptid
) == -1)
511 warning ("Specified thread %ld seems to have terminated",
512 GET_THREAD (save_ptid
));
515 rtnval
= procfs_ops
.to_wait (ptid
, ourstatus
);
517 if (ourstatus
->kind
!= TARGET_WAITKIND_EXITED
)
519 /* Map the LWP of interest back to the appropriate thread ID */
520 rtnval
= lwp_to_thread (rtnval
);
521 if (PIDGET (rtnval
) == -1)
524 /* See if we have a new thread */
525 if (is_thread (rtnval
)
526 && !ptid_equal (rtnval
, save_ptid
)
527 && !in_thread_list (rtnval
))
529 printf_filtered ("[New %s]\n", target_pid_to_str (rtnval
));
534 /* During process initialization, we may get here without the thread package
535 being initialized, since that can only happen after we've found the shared
538 do_cleanups (old_chain
);
544 sol_thread_fetch_registers (int regno
)
547 td_thrhandle_t thandle
;
550 prfpregset_t fpregset
;
556 if (!is_thread (inferior_ptid
))
557 { /* LWP: pass the request on to procfs.c */
558 if (target_has_execution
)
559 procfs_ops
.to_fetch_registers (regno
);
561 orig_core_ops
.to_fetch_registers (regno
);
565 /* Solaris thread: convert inferior_ptid into a td_thrhandle_t */
567 thread
= GET_THREAD (inferior_ptid
);
570 error ("sol_thread_fetch_registers: thread == 0");
572 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
574 error ("sol_thread_fetch_registers: td_ta_map_id2thr: %s",
575 td_err_string (val
));
577 /* Get the integer regs */
579 val
= p_td_thr_getgregs (&thandle
, gregset
);
581 && val
!= TD_PARTIALREG
)
582 error ("sol_thread_fetch_registers: td_thr_getgregs %s",
583 td_err_string (val
));
585 /* For the sparc, TD_PARTIALREG means that only i0->i7, l0->l7, pc and sp
586 are saved (by a thread context switch). */
588 /* And, now the fp regs */
590 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
592 && val
!= TD_NOFPREGS
)
593 error ("sol_thread_fetch_registers: td_thr_getfpregs %s",
594 td_err_string (val
));
596 /* Note that we must call supply_{g fp}regset *after* calling the td routines
597 because the td routines call ps_lget* which affect the values stored in the
600 supply_gregset ((gdb_gregset_t
*) &gregset
);
601 supply_fpregset ((gdb_fpregset_t
*) &fpregset
);
604 /* thread_db doesn't seem to handle this right */
605 val
= td_thr_getxregsize (&thandle
, &xregsize
);
606 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
607 error ("sol_thread_fetch_registers: td_thr_getxregsize %s",
608 td_err_string (val
));
612 xregset
= alloca (xregsize
);
613 val
= td_thr_getxregs (&thandle
, xregset
);
615 error ("sol_thread_fetch_registers: td_thr_getxregs %s",
616 td_err_string (val
));
622 sol_thread_store_registers (int regno
)
625 td_thrhandle_t thandle
;
628 prfpregset_t fpregset
;
634 if (!is_thread (inferior_ptid
))
635 { /* LWP: pass the request on to procfs.c */
636 procfs_ops
.to_store_registers (regno
);
640 /* Solaris thread: convert inferior_ptid into a td_thrhandle_t */
642 thread
= GET_THREAD (inferior_ptid
);
644 val
= p_td_ta_map_id2thr (main_ta
, thread
, &thandle
);
646 error ("sol_thread_store_registers: td_ta_map_id2thr %s",
647 td_err_string (val
));
650 { /* Not writing all the regs */
651 char old_value
[MAX_REGISTER_SIZE
];
653 /* Save new register value. */
654 regcache_collect (regno
, old_value
);
656 val
= p_td_thr_getgregs (&thandle
, gregset
);
658 error ("sol_thread_store_registers: td_thr_getgregs %s",
659 td_err_string (val
));
660 val
= p_td_thr_getfpregs (&thandle
, &fpregset
);
662 error ("sol_thread_store_registers: td_thr_getfpregs %s",
663 td_err_string (val
));
665 /* Restore new register value. */
666 supply_register (regno
, old_value
);
669 /* thread_db doesn't seem to handle this right */
670 val
= td_thr_getxregsize (&thandle
, &xregsize
);
671 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
672 error ("sol_thread_store_registers: td_thr_getxregsize %s",
673 td_err_string (val
));
677 xregset
= alloca (xregsize
);
678 val
= td_thr_getxregs (&thandle
, xregset
);
680 error ("sol_thread_store_registers: td_thr_getxregs %s",
681 td_err_string (val
));
686 fill_gregset ((gdb_gregset_t
*) &gregset
, regno
);
687 fill_fpregset ((gdb_fpregset_t
*) &fpregset
, regno
);
689 val
= p_td_thr_setgregs (&thandle
, gregset
);
691 error ("sol_thread_store_registers: td_thr_setgregs %s",
692 td_err_string (val
));
693 val
= p_td_thr_setfpregs (&thandle
, &fpregset
);
695 error ("sol_thread_store_registers: td_thr_setfpregs %s",
696 td_err_string (val
));
699 /* thread_db doesn't seem to handle this right */
700 val
= td_thr_getxregsize (&thandle
, &xregsize
);
701 if (val
!= TD_OK
&& val
!= TD_NOXREGS
)
702 error ("sol_thread_store_registers: td_thr_getxregsize %s",
703 td_err_string (val
));
705 /* Should probably do something about writing the xregs here, but what are
710 /* Get ready to modify the registers array. On machines which store
711 individual registers, this doesn't need to do anything. On machines
712 which store all the registers in one fell swoop, this makes sure
713 that registers contains all the registers from the program being
717 sol_thread_prepare_to_store (void)
719 procfs_ops
.to_prepare_to_store ();
722 /* Transfer LEN bytes between GDB address MYADDR and target address
723 MEMADDR. If DOWRITE is non-zero, transfer them to the target,
724 otherwise transfer them from the target. TARGET is unused.
726 Returns the number of bytes transferred. */
729 sol_thread_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int dowrite
,
730 struct mem_attrib
*attrib
,
731 struct target_ops
*target
)
734 struct cleanup
*old_chain
;
736 old_chain
= save_inferior_ptid ();
738 if (is_thread (inferior_ptid
) || /* A thread */
739 !target_thread_alive (inferior_ptid
)) /* An lwp, but not alive */
740 inferior_ptid
= procfs_first_available (); /* Find any live lwp. */
741 /* Note: don't need to call switch_to_thread; we're just reading memory. */
743 if (target_has_execution
)
744 retval
= procfs_ops
.to_xfer_memory (memaddr
, myaddr
, len
,
745 dowrite
, attrib
, target
);
747 retval
= orig_core_ops
.to_xfer_memory (memaddr
, myaddr
, len
,
748 dowrite
, attrib
, target
);
750 do_cleanups (old_chain
);
755 /* Print status information about what we're accessing. */
758 sol_thread_files_info (struct target_ops
*ignore
)
760 procfs_ops
.to_files_info (ignore
);
764 sol_thread_kill_inferior (void)
766 procfs_ops
.to_kill ();
770 sol_thread_notice_signals (ptid_t ptid
)
772 procfs_ops
.to_notice_signals (pid_to_ptid (PIDGET (ptid
)));
775 /* Fork an inferior process, and start debugging it with /proc. */
778 sol_thread_create_inferior (char *exec_file
, char *allargs
, char **env
)
780 procfs_ops
.to_create_inferior (exec_file
, allargs
, env
);
782 if (sol_thread_active
&& !ptid_equal (inferior_ptid
, null_ptid
))
784 main_ph
.ptid
= inferior_ptid
; /* Save for xfer_memory */
786 push_target (&sol_thread_ops
);
788 inferior_ptid
= lwp_to_thread (inferior_ptid
);
789 if (PIDGET (inferior_ptid
) == -1)
790 inferior_ptid
= main_ph
.ptid
;
792 if (!in_thread_list (inferior_ptid
))
793 add_thread (inferior_ptid
);
797 /* This routine is called whenever a new symbol table is read in, or when all
798 symbol tables are removed. libthread_db can only be initialized when it
799 finds the right variables in libthread.so. Since it's a shared library,
800 those variables don't show up until the library gets mapped and the symbol
803 /* This new_objfile event is now managed by a chained function pointer.
804 * It is the callee's responsability to call the next client on the chain.
807 /* Saved pointer to previous owner of the new_objfile event. */
808 static void (*target_new_objfile_chain
) (struct objfile
*);
811 sol_thread_new_objfile (struct objfile
*objfile
)
817 sol_thread_active
= 0;
821 /* don't do anything if init failed to resolve the libthread_db library */
822 if (!procfs_suppress_run
)
825 /* Now, initialize the thread debugging library. This needs to be done after
826 the shared libraries are located because it needs information from the
827 user's thread library. */
832 warning ("sol_thread_new_objfile: td_init: %s", td_err_string (val
));
836 val
= p_td_ta_new (&main_ph
, &main_ta
);
837 if (val
== TD_NOLIBTHREAD
)
839 else if (val
!= TD_OK
)
841 warning ("sol_thread_new_objfile: td_ta_new: %s", td_err_string (val
));
845 sol_thread_active
= 1;
847 /* Call predecessor on chain, if any. */
848 if (target_new_objfile_chain
)
849 target_new_objfile_chain (objfile
);
852 /* Clean up after the inferior dies. */
855 sol_thread_mourn_inferior (void)
857 unpush_target (&sol_thread_ops
);
858 procfs_ops
.to_mourn_inferior ();
861 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
864 sol_thread_can_run (void)
866 return procfs_suppress_run
;
873 sol_thread_alive - test thread for "aliveness"
877 static bool sol_thread_alive (ptid_t ptid);
881 returns true if thread still active in inferior.
886 sol_thread_alive (ptid_t ptid
)
888 if (is_thread (ptid
)) /* non-kernel thread */
894 pid
= GET_THREAD (ptid
);
895 if ((val
= p_td_ta_map_id2thr (main_ta
, pid
, &th
)) != TD_OK
)
896 return 0; /* thread not found */
897 if ((val
= p_td_thr_validate (&th
)) != TD_OK
)
898 return 0; /* thread not valid */
899 return 1; /* known thread: return true */
902 /* kernel thread (LWP): let procfs test it */
904 if (target_has_execution
)
905 return procfs_ops
.to_thread_alive (ptid
);
907 return orig_core_ops
.to_thread_alive (ptid
);
912 sol_thread_stop (void)
914 procfs_ops
.to_stop ();
917 /* These routines implement the lower half of the thread_db interface. Ie: the
920 /* Various versions of <proc_service.h> have slightly
921 different function prototypes. In particular, we have
924 struct ps_prochandle * const struct ps_prochandle *
929 Which one you have depends on solaris version and what
930 patches you've applied. On the theory that there are
931 only two major variants, we have configure check the
932 prototype of ps_pdwrite (), and use that info to make
933 appropriate typedefs here. */
935 #ifdef PROC_SERVICE_IS_OLD
936 typedef const struct ps_prochandle
*gdb_ps_prochandle_t
;
937 typedef char *gdb_ps_read_buf_t
;
938 typedef char *gdb_ps_write_buf_t
;
939 typedef int gdb_ps_size_t
;
940 typedef paddr_t gdb_ps_addr_t
;
942 typedef struct ps_prochandle
*gdb_ps_prochandle_t
;
943 typedef void *gdb_ps_read_buf_t
;
944 typedef const void *gdb_ps_write_buf_t
;
945 typedef size_t gdb_ps_size_t
;
946 typedef psaddr_t gdb_ps_addr_t
;
950 /* The next four routines are called by thread_db to tell us to stop and stop
951 a particular process or lwp. Since GDB ensures that these are all stopped
952 by the time we call anything in thread_db, these routines need to do
958 ps_pstop (gdb_ps_prochandle_t ph
)
963 /* Process continue */
966 ps_pcontinue (gdb_ps_prochandle_t ph
)
974 ps_lstop (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
982 ps_lcontinue (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
987 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
990 ps_pglobal_lookup (gdb_ps_prochandle_t ph
, const char *ld_object_name
,
991 const char *ld_symbol_name
, gdb_ps_addr_t
* ld_symbol_addr
)
993 struct minimal_symbol
*ms
;
995 ms
= lookup_minimal_symbol (ld_symbol_name
, NULL
, NULL
);
1000 *ld_symbol_addr
= SYMBOL_VALUE_ADDRESS (ms
);
1005 /* Common routine for reading and writing memory. */
1008 rw_common (int dowrite
, const struct ps_prochandle
*ph
, gdb_ps_addr_t addr
,
1009 char *buf
, int size
)
1011 struct cleanup
*old_chain
;
1013 old_chain
= save_inferior_ptid ();
1015 if (is_thread (inferior_ptid
) || /* A thread */
1016 !target_thread_alive (inferior_ptid
)) /* An lwp, but not alive */
1017 inferior_ptid
= procfs_first_available (); /* Find any live lwp. */
1018 /* Note: don't need to call switch_to_thread; we're just reading memory. */
1020 #if defined (__sparcv9)
1021 /* For Sparc64 cross Sparc32, make sure the address has not been
1022 accidentally sign-extended (or whatever) to beyond 32 bits. */
1023 if (bfd_get_arch_size (exec_bfd
) == 32)
1031 /* FIXME: passing 0 as attrib argument. */
1032 if (target_has_execution
)
1033 cc
= procfs_ops
.to_xfer_memory (addr
, buf
, size
,
1034 dowrite
, 0, &procfs_ops
);
1036 cc
= orig_core_ops
.to_xfer_memory (addr
, buf
, size
,
1037 dowrite
, 0, &core_ops
);
1042 print_sys_errmsg ("rw_common (): read", errno
);
1044 print_sys_errmsg ("rw_common (): write", errno
);
1046 do_cleanups (old_chain
);
1053 warning ("rw_common (): unable to read at addr 0x%lx",
1056 warning ("rw_common (): unable to write at addr 0x%lx",
1059 do_cleanups (old_chain
);
1068 do_cleanups (old_chain
);
1073 /* Copies SIZE bytes from target process .data segment to debugger memory. */
1076 ps_pdread (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
1077 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
1079 return rw_common (0, ph
, addr
, buf
, size
);
1082 /* Copies SIZE bytes from debugger memory .data segment to target process. */
1085 ps_pdwrite (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
1086 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
1088 return rw_common (1, ph
, addr
, (char *) buf
, size
);
1091 /* Copies SIZE bytes from target process .text segment to debugger memory. */
1094 ps_ptread (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
1095 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
1097 return rw_common (0, ph
, addr
, buf
, size
);
1100 /* Copies SIZE bytes from debugger memory .text segment to target process. */
1103 ps_ptwrite (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
1104 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
1106 return rw_common (1, ph
, addr
, (char *) buf
, size
);
1109 /* Get integer regs for LWP */
1112 ps_lgetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1113 prgregset_t gregset
)
1115 struct cleanup
*old_chain
;
1117 old_chain
= save_inferior_ptid ();
1119 inferior_ptid
= BUILD_LWP (lwpid
, PIDGET (inferior_ptid
));
1121 if (target_has_execution
)
1122 procfs_ops
.to_fetch_registers (-1);
1124 orig_core_ops
.to_fetch_registers (-1);
1125 fill_gregset ((gdb_gregset_t
*) gregset
, -1);
1127 do_cleanups (old_chain
);
1132 /* Set integer regs for LWP */
1135 ps_lsetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1136 const prgregset_t gregset
)
1138 struct cleanup
*old_chain
;
1140 old_chain
= save_inferior_ptid ();
1142 inferior_ptid
= BUILD_LWP (lwpid
, PIDGET (inferior_ptid
));
1144 supply_gregset ((gdb_gregset_t
*) gregset
);
1145 if (target_has_execution
)
1146 procfs_ops
.to_store_registers (-1);
1148 orig_core_ops
.to_store_registers (-1);
1150 do_cleanups (old_chain
);
1155 /* Log a message (sends to gdb_stderr). */
1158 ps_plog (const char *fmt
,...)
1162 va_start (args
, fmt
);
1164 vfprintf_filtered (gdb_stderr
, fmt
, args
);
1167 /* Get size of extra register set. Currently a noop. */
1170 ps_lgetxregsize (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, int *xregsize
)
1177 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1181 if (ioctl (lwp_fd
, PIOCGXREGSIZE
, ®size
))
1183 if (errno
== EINVAL
)
1184 return PS_NOFREGS
; /* XXX Wrong code, but this is the closest
1185 thing in proc_service.h */
1187 print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno
);
1195 /* Get extra register set. Currently a noop. */
1198 ps_lgetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
1204 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1208 if (ioctl (lwp_fd
, PIOCGXREG
, xregset
))
1210 print_sys_errmsg ("ps_lgetxregs (): PIOCGXREG", errno
);
1218 /* Set extra register set. Currently a noop. */
1221 ps_lsetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
1227 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1231 if (ioctl (lwp_fd
, PIOCSXREG
, xregset
))
1233 print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno
);
1241 /* Get floating-point regs for LWP */
1244 ps_lgetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1245 prfpregset_t
* fpregset
)
1247 struct cleanup
*old_chain
;
1249 old_chain
= save_inferior_ptid ();
1251 inferior_ptid
= BUILD_LWP (lwpid
, PIDGET (inferior_ptid
));
1253 if (target_has_execution
)
1254 procfs_ops
.to_fetch_registers (-1);
1256 orig_core_ops
.to_fetch_registers (-1);
1257 fill_fpregset ((gdb_fpregset_t
*) fpregset
, -1);
1259 do_cleanups (old_chain
);
1264 /* Set floating-point regs for LWP */
1267 ps_lsetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1268 const prfpregset_t
* fpregset
)
1270 struct cleanup
*old_chain
;
1272 old_chain
= save_inferior_ptid ();
1274 inferior_ptid
= BUILD_LWP (lwpid
, PIDGET (inferior_ptid
));
1276 supply_fpregset ((gdb_fpregset_t
*) fpregset
);
1277 if (target_has_execution
)
1278 procfs_ops
.to_store_registers (-1);
1280 orig_core_ops
.to_store_registers (-1);
1282 do_cleanups (old_chain
);
1287 #ifdef PR_MODEL_LP64
1288 /* Identify process as 32-bit or 64-bit.
1289 At the moment I'm using bfd to do this.
1290 There might be a more solaris-specific (eg. procfs) method,
1291 but this ought to work. */
1294 ps_pdmodel (gdb_ps_prochandle_t ph
, int *data_model
)
1297 *data_model
= PR_MODEL_UNKNOWN
;
1298 else if (bfd_get_arch_size (exec_bfd
) == 32)
1299 *data_model
= PR_MODEL_ILP32
;
1301 *data_model
= PR_MODEL_LP64
;
1305 #endif /* PR_MODEL_LP64 */
1307 #ifdef TM_I386SOL2_H
1309 /* Reads the local descriptor table of a LWP. */
1312 ps_lgetLDT (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1315 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c */
1316 extern struct ssd
*procfs_find_LDT_entry (ptid_t
);
1319 /* FIXME: can't I get the process ID from the prochandle or something?
1322 if (PIDGET (inferior_ptid
) <= 0 || lwpid
<= 0)
1325 ret
= procfs_find_LDT_entry (BUILD_LWP (lwpid
, PIDGET (inferior_ptid
)));
1328 memcpy (pldt
, ret
, sizeof (struct ssd
));
1331 else /* LDT not found. */
1334 #endif /* TM_I386SOL2_H */
1336 /* Convert a pid to printable form. */
1339 solaris_pid_to_str (ptid_t ptid
)
1341 static char buf
[100];
1343 /* in case init failed to resolve the libthread_db library */
1344 if (!procfs_suppress_run
)
1345 return procfs_pid_to_str (ptid
);
1347 if (is_thread (ptid
))
1351 lwp
= thread_to_lwp (ptid
, -2);
1353 if (PIDGET (lwp
) == -1)
1354 sprintf (buf
, "Thread %ld (defunct)", GET_THREAD (ptid
));
1355 else if (PIDGET (lwp
) != -2)
1356 sprintf (buf
, "Thread %ld (LWP %ld)", GET_THREAD (ptid
), GET_LWP (lwp
));
1358 sprintf (buf
, "Thread %ld ", GET_THREAD (ptid
));
1360 else if (GET_LWP (ptid
) != 0)
1361 sprintf (buf
, "LWP %ld ", GET_LWP (ptid
));
1363 sprintf (buf
, "process %d ", PIDGET (ptid
));
1369 /* Worker bee for find_new_threads
1370 Callback function that gets called once per USER thread (i.e., not
1374 sol_find_new_threads_callback (const td_thrhandle_t
*th
, void *ignored
)
1380 if ((retval
= p_td_thr_get_info (th
, &ti
)) != TD_OK
)
1384 ptid
= BUILD_THREAD (ti
.ti_tid
, PIDGET (inferior_ptid
));
1385 if (!in_thread_list (ptid
))
1392 sol_find_new_threads (void)
1394 /* don't do anything if init failed to resolve the libthread_db library */
1395 if (!procfs_suppress_run
)
1398 if (PIDGET (inferior_ptid
) == -1)
1400 printf_filtered ("No process.\n");
1403 procfs_ops
.to_find_new_threads (); /* first find new kernel threads */
1404 p_td_ta_thr_iter (main_ta
, sol_find_new_threads_callback
, (void *) 0,
1405 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1406 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1410 sol_core_open (char *filename
, int from_tty
)
1412 orig_core_ops
.to_open (filename
, from_tty
);
1416 sol_core_close (int quitting
)
1418 orig_core_ops
.to_close (quitting
);
1422 sol_core_detach (char *args
, int from_tty
)
1424 unpush_target (&core_ops
);
1425 orig_core_ops
.to_detach (args
, from_tty
);
1429 sol_core_files_info (struct target_ops
*t
)
1431 orig_core_ops
.to_files_info (t
);
1434 /* Worker bee for info sol-thread command. This is a callback function that
1435 gets called once for each Solaris thread (ie. not kernel thread) in the
1436 inferior. Print anything interesting that we can think of. */
1439 info_cb (const td_thrhandle_t
*th
, void *s
)
1444 if ((ret
= p_td_thr_get_info (th
, &ti
)) == TD_OK
)
1446 printf_filtered ("%s thread #%d, lwp %d, ",
1447 ti
.ti_type
== TD_THR_SYSTEM
? "system" : "user ",
1448 ti
.ti_tid
, ti
.ti_lid
);
1449 switch (ti
.ti_state
)
1452 case TD_THR_UNKNOWN
:
1453 printf_filtered ("<unknown state>");
1455 case TD_THR_STOPPED
:
1456 printf_filtered ("(stopped)");
1459 printf_filtered ("(run) ");
1462 printf_filtered ("(active) ");
1465 printf_filtered ("(zombie) ");
1468 printf_filtered ("(asleep) ");
1470 case TD_THR_STOPPED_ASLEEP
:
1471 printf_filtered ("(stopped asleep)");
1474 /* Print thr_create start function: */
1475 if (ti
.ti_startfunc
!= 0)
1477 struct minimal_symbol
*msym
;
1478 msym
= lookup_minimal_symbol_by_pc (ti
.ti_startfunc
);
1480 printf_filtered (" startfunc: %s\n", DEPRECATED_SYMBOL_NAME (msym
));
1482 printf_filtered (" startfunc: 0x%s\n", paddr (ti
.ti_startfunc
));
1485 /* If thread is asleep, print function that went to sleep: */
1486 if (ti
.ti_state
== TD_THR_SLEEP
)
1488 struct minimal_symbol
*msym
;
1489 msym
= lookup_minimal_symbol_by_pc (ti
.ti_pc
);
1491 printf_filtered (" - Sleep func: %s\n", DEPRECATED_SYMBOL_NAME (msym
));
1493 printf_filtered (" - Sleep func: 0x%s\n", paddr (ti
.ti_startfunc
));
1496 /* Wrap up line, if necessary */
1497 if (ti
.ti_state
!= TD_THR_SLEEP
&& ti
.ti_startfunc
== 0)
1498 printf_filtered ("\n"); /* don't you hate counting newlines? */
1501 warning ("info sol-thread: failed to get info for thread.");
1506 /* List some state about each Solaris user thread in the inferior. */
1509 info_solthreads (char *args
, int from_tty
)
1511 p_td_ta_thr_iter (main_ta
, info_cb
, args
,
1512 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1513 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1517 sol_find_memory_regions (int (*func
) (CORE_ADDR
,
1523 return procfs_ops
.to_find_memory_regions (func
, data
);
1527 sol_make_note_section (bfd
*obfd
, int *note_size
)
1529 return procfs_ops
.to_make_corefile_notes (obfd
, note_size
);
1533 ignore (CORE_ADDR addr
, char *contents
)
1540 init_sol_thread_ops (void)
1542 sol_thread_ops
.to_shortname
= "solaris-threads";
1543 sol_thread_ops
.to_longname
= "Solaris threads and pthread.";
1544 sol_thread_ops
.to_doc
= "Solaris threads and pthread support.";
1545 sol_thread_ops
.to_open
= sol_thread_open
;
1546 sol_thread_ops
.to_attach
= sol_thread_attach
;
1547 sol_thread_ops
.to_detach
= sol_thread_detach
;
1548 sol_thread_ops
.to_resume
= sol_thread_resume
;
1549 sol_thread_ops
.to_wait
= sol_thread_wait
;
1550 sol_thread_ops
.to_fetch_registers
= sol_thread_fetch_registers
;
1551 sol_thread_ops
.to_store_registers
= sol_thread_store_registers
;
1552 sol_thread_ops
.to_prepare_to_store
= sol_thread_prepare_to_store
;
1553 sol_thread_ops
.to_xfer_memory
= sol_thread_xfer_memory
;
1554 sol_thread_ops
.to_files_info
= sol_thread_files_info
;
1555 sol_thread_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1556 sol_thread_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1557 sol_thread_ops
.to_terminal_init
= terminal_init_inferior
;
1558 sol_thread_ops
.to_terminal_inferior
= terminal_inferior
;
1559 sol_thread_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1560 sol_thread_ops
.to_terminal_ours
= terminal_ours
;
1561 sol_thread_ops
.to_terminal_save_ours
= terminal_save_ours
;
1562 sol_thread_ops
.to_terminal_info
= child_terminal_info
;
1563 sol_thread_ops
.to_kill
= sol_thread_kill_inferior
;
1564 sol_thread_ops
.to_create_inferior
= sol_thread_create_inferior
;
1565 sol_thread_ops
.to_mourn_inferior
= sol_thread_mourn_inferior
;
1566 sol_thread_ops
.to_can_run
= sol_thread_can_run
;
1567 sol_thread_ops
.to_notice_signals
= sol_thread_notice_signals
;
1568 sol_thread_ops
.to_thread_alive
= sol_thread_alive
;
1569 sol_thread_ops
.to_pid_to_str
= solaris_pid_to_str
;
1570 sol_thread_ops
.to_find_new_threads
= sol_find_new_threads
;
1571 sol_thread_ops
.to_stop
= sol_thread_stop
;
1572 sol_thread_ops
.to_stratum
= process_stratum
;
1573 sol_thread_ops
.to_has_all_memory
= 1;
1574 sol_thread_ops
.to_has_memory
= 1;
1575 sol_thread_ops
.to_has_stack
= 1;
1576 sol_thread_ops
.to_has_registers
= 1;
1577 sol_thread_ops
.to_has_execution
= 1;
1578 sol_thread_ops
.to_has_thread_control
= tc_none
;
1579 sol_thread_ops
.to_find_memory_regions
= sol_find_memory_regions
;
1580 sol_thread_ops
.to_make_corefile_notes
= sol_make_note_section
;
1581 sol_thread_ops
.to_magic
= OPS_MAGIC
;
1586 init_sol_core_ops (void)
1588 sol_core_ops
.to_shortname
= "solaris-core";
1589 sol_core_ops
.to_longname
= "Solaris core threads and pthread.";
1590 sol_core_ops
.to_doc
= "Solaris threads and pthread support for core files.";
1591 sol_core_ops
.to_open
= sol_core_open
;
1592 sol_core_ops
.to_close
= sol_core_close
;
1593 sol_core_ops
.to_attach
= sol_thread_attach
;
1594 sol_core_ops
.to_detach
= sol_core_detach
;
1595 sol_core_ops
.to_fetch_registers
= sol_thread_fetch_registers
;
1596 sol_core_ops
.to_xfer_memory
= sol_thread_xfer_memory
;
1597 sol_core_ops
.to_files_info
= sol_core_files_info
;
1598 sol_core_ops
.to_insert_breakpoint
= ignore
;
1599 sol_core_ops
.to_remove_breakpoint
= ignore
;
1600 sol_core_ops
.to_create_inferior
= sol_thread_create_inferior
;
1601 sol_core_ops
.to_stratum
= core_stratum
;
1602 sol_core_ops
.to_has_memory
= 1;
1603 sol_core_ops
.to_has_stack
= 1;
1604 sol_core_ops
.to_has_registers
= 1;
1605 sol_core_ops
.to_has_thread_control
= tc_none
;
1606 sol_core_ops
.to_thread_alive
= sol_thread_alive
;
1607 sol_core_ops
.to_pid_to_str
= solaris_pid_to_str
;
1608 /* On Solaris/x86, when debugging a threaded core file from process <n>,
1609 the following causes "info threads" to produce "procfs: couldn't find pid
1610 <n> in procinfo list" where <n> is the pid of the process that produced
1611 the core file. Disable it for now. */
1612 /* sol_core_ops.to_find_new_threads = sol_find_new_threads; */
1613 sol_core_ops
.to_magic
= OPS_MAGIC
;
1616 /* we suppress the call to add_target of core_ops in corelow because
1617 if there are two targets in the stratum core_stratum, find_core_target
1618 won't know which one to return. see corelow.c for an additonal
1619 comment on coreops_suppress_target. */
1620 int coreops_suppress_target
= 1;
1623 _initialize_sol_thread (void)
1627 init_sol_thread_ops ();
1628 init_sol_core_ops ();
1630 dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
);
1634 #define resolve(X) \
1635 if (!(p_##X = dlsym (dlhandle, #X))) \
1639 resolve (td_ta_new
);
1640 resolve (td_ta_delete
);
1642 resolve (td_ta_get_ph
);
1643 resolve (td_ta_get_nthreads
);
1644 resolve (td_ta_tsd_iter
);
1645 resolve (td_ta_thr_iter
);
1646 resolve (td_thr_validate
);
1647 resolve (td_thr_tsd
);
1648 resolve (td_thr_get_info
);
1649 resolve (td_thr_getfpregs
);
1650 resolve (td_thr_getxregsize
);
1651 resolve (td_thr_getxregs
);
1652 resolve (td_thr_sigsetmask
);
1653 resolve (td_thr_setprio
);
1654 resolve (td_thr_setsigpending
);
1655 resolve (td_thr_setfpregs
);
1656 resolve (td_thr_setxregs
);
1657 resolve (td_ta_map_id2thr
);
1658 resolve (td_ta_map_lwp2thr
);
1659 resolve (td_thr_getgregs
);
1660 resolve (td_thr_setgregs
);
1662 add_target (&sol_thread_ops
);
1664 procfs_suppress_run
= 1;
1666 add_cmd ("sol-threads", class_maintenance
, info_solthreads
,
1667 "Show info on Solaris user threads.\n", &maintenanceinfolist
);
1669 memcpy (&orig_core_ops
, &core_ops
, sizeof (struct target_ops
));
1670 memcpy (&core_ops
, &sol_core_ops
, sizeof (struct target_ops
));
1671 add_target (&core_ops
);
1673 /* Hook into new_objfile notification. */
1674 target_new_objfile_chain
= target_new_objfile_hook
;
1675 target_new_objfile_hook
= sol_thread_new_objfile
;
1680 fprintf_unfiltered (gdb_stderr
, "[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
1685 /* allow the user to debug non-threaded core files */
1686 add_target (&core_ops
);