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 struct cleanup
*save_inferior_ptid (void);
101 static void restore_inferior_ptid (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 ptid_t
thread_to_lwp (ptid_t thread_id
, int default_lwp
);
105 static void sol_thread_resume (ptid_t ptid
, int step
, enum target_signal signo
);
106 static ptid_t
lwp_to_thread (ptid_t lwp
);
107 static int sol_thread_alive (ptid_t ptid
);
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 tpid_t 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 (ptid_t 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 pid_to_ptid (-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 pid_to_ptid (-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)
332 return pid_to_ptid (default_lwp
);
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 (ptid_t 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 pid_to_ptid (-1); /* defunct lwp */
376 val
= p_td_ta_map_lwp2thr (main_ta
, GET_LWP (lwp
), &th
);
378 return pid_to_ptid (-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 pid_to_ptid (-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_ptid - Save inferior_ptid on the cleanup list
403 restore_inferior_ptid - Restore inferior_ptid from the cleanup list
407 struct cleanup *save_inferior_ptid ()
408 void restore_inferior_ptid (int pid)
412 These two functions act in unison to restore inferior_ptid in
417 inferior_ptid 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_ptid gets restored (in case of errors), you
420 need to call save_inferior_ptid 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_ptid (void)
429 ptid_t
*saved_ptid
= xmalloc (sizeof (ptid_t
));
430 *saved_ptid
= inferior_ptid
;
431 return make_cleanup (restore_inferior_ptid
, saved_ptid
);
435 restore_inferior_ptid (void *data
)
437 ptid_t
*saved_ptid
= data
;
438 inferior_ptid
= *saved_ptid
;
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
.ptid
= inferior_ptid
; /* Save for xfer_memory */
469 push_target (&sol_thread_ops
);
470 inferior_ptid
= lwp_to_thread (inferior_ptid
);
471 if (PIDGET (inferior_ptid
) == -1)
472 inferior_ptid
= main_ph
.ptid
;
474 add_thread (inferior_ptid
);
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_ptid
= pid_to_ptid (PIDGET (main_ph
.ptid
));
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 (ptid_t ptid
, int step
, enum target_signal signo
)
503 struct cleanup
*old_chain
;
505 old_chain
= save_inferior_ptid ();
507 inferior_ptid
= thread_to_lwp (inferior_ptid
, PIDGET (main_ph
.ptid
));
508 if (PIDGET (inferior_ptid
) == -1)
509 inferior_ptid
= procfs_first_available ();
511 if (PIDGET (ptid
) != -1)
513 ptid_t save_ptid
= ptid
;
515 ptid
= thread_to_lwp (ptid
, -2);
516 if (PIDGET (ptid
) == -2) /* Inactive thread */
517 error ("This version of Solaris can't start inactive threads.");
518 if (info_verbose
&& PIDGET (ptid
) == -1)
519 warning ("Specified thread %ld seems to have terminated",
520 GET_THREAD (save_ptid
));
523 procfs_ops
.to_resume (ptid
, 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 (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
536 struct cleanup
*old_chain
;
538 save_ptid
= inferior_ptid
;
539 old_chain
= save_inferior_ptid ();
541 inferior_ptid
= thread_to_lwp (inferior_ptid
, PIDGET (main_ph
.ptid
));
542 if (PIDGET (inferior_ptid
) == -1)
543 inferior_ptid
= procfs_first_available ();
545 if (PIDGET (ptid
) != -1)
547 ptid_t save_ptid
= ptid
;
549 ptid
= thread_to_lwp (ptid
, -2);
550 if (PIDGET (ptid
) == -2) /* Inactive thread */
551 error ("This version of Solaris can't start inactive threads.");
552 if (info_verbose
&& PIDGET (ptid
) == -1)
553 warning ("Specified thread %ld seems to have terminated",
554 GET_THREAD (save_ptid
));
557 rtnval
= procfs_ops
.to_wait (ptid
, 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
);
563 if (PIDGET (rtnval
) == -1)
566 /* See if we have a new thread */
567 if (is_thread (rtnval
)
568 && !ptid_equal (rtnval
, save_ptid
)
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_ptid
))
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_ptid into a td_thrhandle_t */
609 thread
= GET_THREAD (inferior_ptid
);
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_ptid
))
677 { /* LWP: pass the request on to procfs.c */
678 procfs_ops
.to_store_registers (regno
);
682 /* Solaris thread: convert inferior_ptid into a td_thrhandle_t */
684 thread
= GET_THREAD (inferior_ptid
);
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_ptid ();
779 if (is_thread (inferior_ptid
) || /* A thread */
780 !target_thread_alive (inferior_ptid
)) /* An lwp, but not alive */
781 inferior_ptid
= 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 (ptid_t ptid
)
813 procfs_ops
.to_notice_signals (pid_to_ptid (PIDGET (ptid
)));
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
&& !ptid_equal (inferior_ptid
, null_ptid
))
825 main_ph
.ptid
= inferior_ptid
; /* Save for xfer_memory */
827 push_target (&sol_thread_ops
);
829 inferior_ptid
= lwp_to_thread (inferior_ptid
);
830 if (PIDGET (inferior_ptid
) == -1)
831 inferior_ptid
= main_ph
.ptid
;
833 if (!in_thread_list (inferior_ptid
))
834 add_thread (inferior_ptid
);
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 (ptid_t ptid);
922 returns true if thread still active in inferior.
927 sol_thread_alive (ptid_t ptid
)
929 if (is_thread (ptid
)) /* non-kernel thread */
935 pid
= GET_THREAD (ptid
);
936 if ((val
= p_td_ta_map_id2thr (main_ta
, pid
, &th
)) != TD_OK
)
937 return 0; /* thread not found */
938 if ((val
= p_td_thr_validate (&th
)) != TD_OK
)
939 return 0; /* thread not valid */
940 return 1; /* known thread: return true */
943 /* kernel thread (LWP): let procfs test it */
945 if (target_has_execution
)
946 return procfs_ops
.to_thread_alive (ptid
);
948 return orig_core_ops
.to_thread_alive (ptid
);
953 sol_thread_stop (void)
955 procfs_ops
.to_stop ();
958 /* These routines implement the lower half of the thread_db interface. Ie: the
961 /* Various versions of <proc_service.h> have slightly
962 different function prototypes. In particular, we have
965 struct ps_prochandle * const struct ps_prochandle *
970 Which one you have depends on solaris version and what
971 patches you've applied. On the theory that there are
972 only two major variants, we have configure check the
973 prototype of ps_pdwrite (), and use that info to make
974 appropriate typedefs here. */
976 #ifdef PROC_SERVICE_IS_OLD
977 typedef const struct ps_prochandle
*gdb_ps_prochandle_t
;
978 typedef char *gdb_ps_read_buf_t
;
979 typedef char *gdb_ps_write_buf_t
;
980 typedef int gdb_ps_size_t
;
981 typedef paddr_t gdb_ps_addr_t
;
983 typedef struct ps_prochandle
*gdb_ps_prochandle_t
;
984 typedef void *gdb_ps_read_buf_t
;
985 typedef const void *gdb_ps_write_buf_t
;
986 typedef size_t gdb_ps_size_t
;
987 typedef psaddr_t gdb_ps_addr_t
;
991 /* The next four routines are called by thread_db to tell us to stop and stop
992 a particular process or lwp. Since GDB ensures that these are all stopped
993 by the time we call anything in thread_db, these routines need to do
999 ps_pstop (gdb_ps_prochandle_t ph
)
1004 /* Process continue */
1007 ps_pcontinue (gdb_ps_prochandle_t ph
)
1015 ps_lstop (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
1023 ps_lcontinue (gdb_ps_prochandle_t ph
, lwpid_t lwpid
)
1028 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
1031 ps_pglobal_lookup (gdb_ps_prochandle_t ph
, const char *ld_object_name
,
1032 const char *ld_symbol_name
, gdb_ps_addr_t
* ld_symbol_addr
)
1034 struct minimal_symbol
*ms
;
1036 ms
= lookup_minimal_symbol (ld_symbol_name
, NULL
, NULL
);
1041 *ld_symbol_addr
= SYMBOL_VALUE_ADDRESS (ms
);
1046 /* Common routine for reading and writing memory. */
1049 rw_common (int dowrite
, const struct ps_prochandle
*ph
, gdb_ps_addr_t addr
,
1050 char *buf
, int size
)
1052 struct cleanup
*old_chain
;
1054 old_chain
= save_inferior_ptid ();
1056 if (is_thread (inferior_ptid
) || /* A thread */
1057 !target_thread_alive (inferior_ptid
)) /* An lwp, but not alive */
1058 inferior_ptid
= procfs_first_available (); /* Find any live lwp. */
1059 /* Note: don't need to call switch_to_thread; we're just reading memory. */
1061 #if defined (__sparcv9)
1062 /* For Sparc64 cross Sparc32, make sure the address has not been
1063 accidentally sign-extended (or whatever) to beyond 32 bits. */
1064 if (bfd_get_arch_size (exec_bfd
) == 32)
1072 /* FIXME: passing 0 as attrib argument. */
1073 if (target_has_execution
)
1074 cc
= procfs_ops
.to_xfer_memory (addr
, buf
, size
,
1075 dowrite
, 0, &procfs_ops
);
1077 cc
= orig_core_ops
.to_xfer_memory (addr
, buf
, size
,
1078 dowrite
, 0, &core_ops
);
1083 print_sys_errmsg ("rw_common (): read", errno
);
1085 print_sys_errmsg ("rw_common (): write", errno
);
1087 do_cleanups (old_chain
);
1094 warning ("rw_common (): unable to read at addr 0x%lx",
1097 warning ("rw_common (): unable to write at addr 0x%lx",
1100 do_cleanups (old_chain
);
1109 do_cleanups (old_chain
);
1114 /* Copies SIZE bytes from target process .data segment to debugger memory. */
1117 ps_pdread (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
1118 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
1120 return rw_common (0, ph
, addr
, buf
, size
);
1123 /* Copies SIZE bytes from debugger memory .data segment to target process. */
1126 ps_pdwrite (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
1127 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
1129 return rw_common (1, ph
, addr
, (char *) buf
, size
);
1132 /* Copies SIZE bytes from target process .text segment to debugger memory. */
1135 ps_ptread (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
1136 gdb_ps_read_buf_t buf
, gdb_ps_size_t size
)
1138 return rw_common (0, ph
, addr
, buf
, size
);
1141 /* Copies SIZE bytes from debugger memory .text segment to target process. */
1144 ps_ptwrite (gdb_ps_prochandle_t ph
, gdb_ps_addr_t addr
,
1145 gdb_ps_write_buf_t buf
, gdb_ps_size_t size
)
1147 return rw_common (1, ph
, addr
, (char *) buf
, size
);
1150 /* Get integer regs for LWP */
1153 ps_lgetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1154 prgregset_t gregset
)
1156 struct cleanup
*old_chain
;
1158 old_chain
= save_inferior_ptid ();
1160 inferior_ptid
= BUILD_LWP (lwpid
, PIDGET (inferior_ptid
));
1162 if (target_has_execution
)
1163 procfs_ops
.to_fetch_registers (-1);
1165 orig_core_ops
.to_fetch_registers (-1);
1166 fill_gregset ((gdb_gregset_t
*) gregset
, -1);
1168 do_cleanups (old_chain
);
1173 /* Set integer regs for LWP */
1176 ps_lsetregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1177 const prgregset_t gregset
)
1179 struct cleanup
*old_chain
;
1181 old_chain
= save_inferior_ptid ();
1183 inferior_ptid
= BUILD_LWP (lwpid
, PIDGET (inferior_ptid
));
1185 supply_gregset ((gdb_gregset_t
*) gregset
);
1186 if (target_has_execution
)
1187 procfs_ops
.to_store_registers (-1);
1189 orig_core_ops
.to_store_registers (-1);
1191 do_cleanups (old_chain
);
1196 /* Log a message (sends to gdb_stderr). */
1199 ps_plog (const char *fmt
,...)
1203 va_start (args
, fmt
);
1205 vfprintf_filtered (gdb_stderr
, fmt
, args
);
1208 /* Get size of extra register set. Currently a noop. */
1211 ps_lgetxregsize (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, int *xregsize
)
1218 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1222 if (ioctl (lwp_fd
, PIOCGXREGSIZE
, ®size
))
1224 if (errno
== EINVAL
)
1225 return PS_NOFREGS
; /* XXX Wrong code, but this is the closest
1226 thing in proc_service.h */
1228 print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno
);
1236 /* Get extra register set. Currently a noop. */
1239 ps_lgetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
1245 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1249 if (ioctl (lwp_fd
, PIOCGXREG
, xregset
))
1251 print_sys_errmsg ("ps_lgetxregs (): PIOCGXREG", errno
);
1259 /* Set extra register set. Currently a noop. */
1262 ps_lsetxregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
, caddr_t xregset
)
1268 val
= get_lwp_fd (ph
, lwpid
, &lwp_fd
);
1272 if (ioctl (lwp_fd
, PIOCSXREG
, xregset
))
1274 print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno
);
1282 /* Get floating-point regs for LWP */
1285 ps_lgetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1286 prfpregset_t
* fpregset
)
1288 struct cleanup
*old_chain
;
1290 old_chain
= save_inferior_ptid ();
1292 inferior_ptid
= BUILD_LWP (lwpid
, PIDGET (inferior_ptid
));
1294 if (target_has_execution
)
1295 procfs_ops
.to_fetch_registers (-1);
1297 orig_core_ops
.to_fetch_registers (-1);
1298 fill_fpregset ((gdb_fpregset_t
*) fpregset
, -1);
1300 do_cleanups (old_chain
);
1305 /* Set floating-point regs for LWP */
1308 ps_lsetfpregs (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1309 const prfpregset_t
* fpregset
)
1311 struct cleanup
*old_chain
;
1313 old_chain
= save_inferior_ptid ();
1315 inferior_ptid
= BUILD_LWP (lwpid
, PIDGET (inferior_ptid
));
1317 supply_fpregset ((gdb_fpregset_t
*) fpregset
);
1318 if (target_has_execution
)
1319 procfs_ops
.to_store_registers (-1);
1321 orig_core_ops
.to_store_registers (-1);
1323 do_cleanups (old_chain
);
1328 #ifdef PR_MODEL_LP64
1329 /* Identify process as 32-bit or 64-bit.
1330 At the moment I'm using bfd to do this.
1331 There might be a more solaris-specific (eg. procfs) method,
1332 but this ought to work. */
1335 ps_pdmodel (gdb_ps_prochandle_t ph
, int *data_model
)
1338 *data_model
= PR_MODEL_UNKNOWN
;
1339 else if (bfd_get_arch_size (exec_bfd
) == 32)
1340 *data_model
= PR_MODEL_ILP32
;
1342 *data_model
= PR_MODEL_LP64
;
1346 #endif /* PR_MODEL_LP64 */
1348 #ifdef TM_I386SOL2_H
1350 /* Reads the local descriptor table of a LWP. */
1353 ps_lgetLDT (gdb_ps_prochandle_t ph
, lwpid_t lwpid
,
1356 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c */
1357 extern struct ssd
*procfs_find_LDT_entry (ptid_t
);
1360 /* FIXME: can't I get the process ID from the prochandle or something?
1363 if (PIDGET (inferior_ptid
) <= 0 || lwpid
<= 0)
1366 ret
= procfs_find_LDT_entry (BUILD_LWP (lwpid
, PIDGET (inferior_ptid
)));
1369 memcpy (pldt
, ret
, sizeof (struct ssd
));
1372 else /* LDT not found. */
1375 #endif /* TM_I386SOL2_H */
1377 /* Convert a pid to printable form. */
1380 solaris_pid_to_str (ptid_t ptid
)
1382 static char buf
[100];
1384 /* in case init failed to resolve the libthread_db library */
1385 if (!procfs_suppress_run
)
1386 return procfs_pid_to_str (ptid
);
1388 if (is_thread (ptid
))
1392 lwp
= thread_to_lwp (ptid
, -2);
1394 if (PIDGET (lwp
) == -1)
1395 sprintf (buf
, "Thread %ld (defunct)", GET_THREAD (ptid
));
1396 else if (PIDGET (lwp
) != -2)
1397 sprintf (buf
, "Thread %ld (LWP %ld)", GET_THREAD (ptid
), GET_LWP (lwp
));
1399 sprintf (buf
, "Thread %ld ", GET_THREAD (ptid
));
1401 else if (GET_LWP (ptid
) != 0)
1402 sprintf (buf
, "LWP %ld ", GET_LWP (ptid
));
1404 sprintf (buf
, "process %d ", PIDGET (ptid
));
1410 /* Worker bee for find_new_threads
1411 Callback function that gets called once per USER thread (i.e., not
1415 sol_find_new_threads_callback (const td_thrhandle_t
*th
, void *ignored
)
1421 if ((retval
= p_td_thr_get_info (th
, &ti
)) != TD_OK
)
1425 ptid
= BUILD_THREAD (ti
.ti_tid
, PIDGET (inferior_ptid
));
1426 if (!in_thread_list (ptid
))
1433 sol_find_new_threads (void)
1435 /* don't do anything if init failed to resolve the libthread_db library */
1436 if (!procfs_suppress_run
)
1439 if (PIDGET (inferior_ptid
) == -1)
1441 printf_filtered ("No process.\n");
1444 procfs_ops
.to_find_new_threads (); /* first find new kernel threads */
1445 p_td_ta_thr_iter (main_ta
, sol_find_new_threads_callback
, (void *) 0,
1446 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1447 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1451 sol_core_open (char *filename
, int from_tty
)
1453 orig_core_ops
.to_open (filename
, from_tty
);
1457 sol_core_close (int quitting
)
1459 orig_core_ops
.to_close (quitting
);
1463 sol_core_detach (char *args
, int from_tty
)
1465 unpush_target (&core_ops
);
1466 orig_core_ops
.to_detach (args
, from_tty
);
1470 sol_core_files_info (struct target_ops
*t
)
1472 orig_core_ops
.to_files_info (t
);
1475 /* Worker bee for info sol-thread command. This is a callback function that
1476 gets called once for each Solaris thread (ie. not kernel thread) in the
1477 inferior. Print anything interesting that we can think of. */
1480 info_cb (const td_thrhandle_t
*th
, void *s
)
1485 if ((ret
= p_td_thr_get_info (th
, &ti
)) == TD_OK
)
1487 printf_filtered ("%s thread #%d, lwp %d, ",
1488 ti
.ti_type
== TD_THR_SYSTEM
? "system" : "user ",
1489 ti
.ti_tid
, ti
.ti_lid
);
1490 switch (ti
.ti_state
)
1493 case TD_THR_UNKNOWN
:
1494 printf_filtered ("<unknown state>");
1496 case TD_THR_STOPPED
:
1497 printf_filtered ("(stopped)");
1500 printf_filtered ("(run) ");
1503 printf_filtered ("(active) ");
1506 printf_filtered ("(zombie) ");
1509 printf_filtered ("(asleep) ");
1511 case TD_THR_STOPPED_ASLEEP
:
1512 printf_filtered ("(stopped asleep)");
1515 /* Print thr_create start function: */
1516 if (ti
.ti_startfunc
!= 0)
1518 struct minimal_symbol
*msym
;
1519 msym
= lookup_minimal_symbol_by_pc (ti
.ti_startfunc
);
1521 printf_filtered (" startfunc: %s\n", SYMBOL_NAME (msym
));
1523 printf_filtered (" startfunc: 0x%s\n", paddr (ti
.ti_startfunc
));
1526 /* If thread is asleep, print function that went to sleep: */
1527 if (ti
.ti_state
== TD_THR_SLEEP
)
1529 struct minimal_symbol
*msym
;
1530 msym
= lookup_minimal_symbol_by_pc (ti
.ti_pc
);
1532 printf_filtered (" - Sleep func: %s\n", SYMBOL_NAME (msym
));
1534 printf_filtered (" - Sleep func: 0x%s\n", paddr (ti
.ti_startfunc
));
1537 /* Wrap up line, if necessary */
1538 if (ti
.ti_state
!= TD_THR_SLEEP
&& ti
.ti_startfunc
== 0)
1539 printf_filtered ("\n"); /* don't you hate counting newlines? */
1542 warning ("info sol-thread: failed to get info for thread.");
1547 /* List some state about each Solaris user thread in the inferior. */
1550 info_solthreads (char *args
, int from_tty
)
1552 p_td_ta_thr_iter (main_ta
, info_cb
, args
,
1553 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1554 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1558 ignore (CORE_ADDR addr
, char *contents
)
1565 init_sol_thread_ops (void)
1567 sol_thread_ops
.to_shortname
= "solaris-threads";
1568 sol_thread_ops
.to_longname
= "Solaris threads and pthread.";
1569 sol_thread_ops
.to_doc
= "Solaris threads and pthread support.";
1570 sol_thread_ops
.to_open
= sol_thread_open
;
1571 sol_thread_ops
.to_close
= 0;
1572 sol_thread_ops
.to_attach
= sol_thread_attach
;
1573 sol_thread_ops
.to_detach
= sol_thread_detach
;
1574 sol_thread_ops
.to_resume
= sol_thread_resume
;
1575 sol_thread_ops
.to_wait
= sol_thread_wait
;
1576 sol_thread_ops
.to_fetch_registers
= sol_thread_fetch_registers
;
1577 sol_thread_ops
.to_store_registers
= sol_thread_store_registers
;
1578 sol_thread_ops
.to_prepare_to_store
= sol_thread_prepare_to_store
;
1579 sol_thread_ops
.to_xfer_memory
= sol_thread_xfer_memory
;
1580 sol_thread_ops
.to_files_info
= sol_thread_files_info
;
1581 sol_thread_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1582 sol_thread_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1583 sol_thread_ops
.to_terminal_init
= terminal_init_inferior
;
1584 sol_thread_ops
.to_terminal_inferior
= terminal_inferior
;
1585 sol_thread_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1586 sol_thread_ops
.to_terminal_ours
= terminal_ours
;
1587 sol_thread_ops
.to_terminal_info
= child_terminal_info
;
1588 sol_thread_ops
.to_kill
= sol_thread_kill_inferior
;
1589 sol_thread_ops
.to_load
= 0;
1590 sol_thread_ops
.to_lookup_symbol
= 0;
1591 sol_thread_ops
.to_create_inferior
= sol_thread_create_inferior
;
1592 sol_thread_ops
.to_mourn_inferior
= sol_thread_mourn_inferior
;
1593 sol_thread_ops
.to_can_run
= sol_thread_can_run
;
1594 sol_thread_ops
.to_notice_signals
= sol_thread_notice_signals
;
1595 sol_thread_ops
.to_thread_alive
= sol_thread_alive
;
1596 sol_thread_ops
.to_pid_to_str
= solaris_pid_to_str
;
1597 sol_thread_ops
.to_find_new_threads
= sol_find_new_threads
;
1598 sol_thread_ops
.to_stop
= sol_thread_stop
;
1599 sol_thread_ops
.to_stratum
= process_stratum
;
1600 sol_thread_ops
.to_has_all_memory
= 1;
1601 sol_thread_ops
.to_has_memory
= 1;
1602 sol_thread_ops
.to_has_stack
= 1;
1603 sol_thread_ops
.to_has_registers
= 1;
1604 sol_thread_ops
.to_has_execution
= 1;
1605 sol_thread_ops
.to_has_thread_control
= tc_none
;
1606 sol_thread_ops
.to_sections
= 0;
1607 sol_thread_ops
.to_sections_end
= 0;
1608 sol_thread_ops
.to_magic
= OPS_MAGIC
;
1613 init_sol_core_ops (void)
1615 sol_core_ops
.to_shortname
= "solaris-core";
1616 sol_core_ops
.to_longname
= "Solaris core threads and pthread.";
1617 sol_core_ops
.to_doc
= "Solaris threads and pthread support for core files.";
1618 sol_core_ops
.to_open
= sol_core_open
;
1619 sol_core_ops
.to_close
= sol_core_close
;
1620 sol_core_ops
.to_attach
= sol_thread_attach
;
1621 sol_core_ops
.to_detach
= sol_core_detach
;
1622 /* sol_core_ops.to_resume = 0; */
1623 /* sol_core_ops.to_wait = 0; */
1624 sol_core_ops
.to_fetch_registers
= sol_thread_fetch_registers
;
1625 /* sol_core_ops.to_store_registers = 0; */
1626 /* sol_core_ops.to_prepare_to_store = 0; */
1627 sol_core_ops
.to_xfer_memory
= sol_thread_xfer_memory
;
1628 sol_core_ops
.to_files_info
= sol_core_files_info
;
1629 sol_core_ops
.to_insert_breakpoint
= ignore
;
1630 sol_core_ops
.to_remove_breakpoint
= ignore
;
1631 /* sol_core_ops.to_terminal_init = 0; */
1632 /* sol_core_ops.to_terminal_inferior = 0; */
1633 /* sol_core_ops.to_terminal_ours_for_output = 0; */
1634 /* sol_core_ops.to_terminal_ours = 0; */
1635 /* sol_core_ops.to_terminal_info = 0; */
1636 /* sol_core_ops.to_kill = 0; */
1637 /* sol_core_ops.to_load = 0; */
1638 /* sol_core_ops.to_lookup_symbol = 0; */
1639 sol_core_ops
.to_create_inferior
= sol_thread_create_inferior
;
1640 sol_core_ops
.to_stratum
= core_stratum
;
1641 sol_core_ops
.to_has_all_memory
= 0;
1642 sol_core_ops
.to_has_memory
= 1;
1643 sol_core_ops
.to_has_stack
= 1;
1644 sol_core_ops
.to_has_registers
= 1;
1645 sol_core_ops
.to_has_execution
= 0;
1646 sol_core_ops
.to_has_thread_control
= tc_none
;
1647 sol_core_ops
.to_thread_alive
= sol_thread_alive
;
1648 sol_core_ops
.to_pid_to_str
= solaris_pid_to_str
;
1649 /* On Solaris/x86, when debugging a threaded core file from process <n>,
1650 the following causes "info threads" to produce "procfs: couldn't find pid
1651 <n> in procinfo list" where <n> is the pid of the process that produced
1652 the core file. Disable it for now. */
1653 /* sol_core_ops.to_find_new_threads = sol_find_new_threads; */
1654 sol_core_ops
.to_sections
= 0;
1655 sol_core_ops
.to_sections_end
= 0;
1656 sol_core_ops
.to_magic
= OPS_MAGIC
;
1659 /* we suppress the call to add_target of core_ops in corelow because
1660 if there are two targets in the stratum core_stratum, find_core_target
1661 won't know which one to return. see corelow.c for an additonal
1662 comment on coreops_suppress_target. */
1663 int coreops_suppress_target
= 1;
1666 _initialize_sol_thread (void)
1670 init_sol_thread_ops ();
1671 init_sol_core_ops ();
1673 dlhandle
= dlopen ("libthread_db.so.1", RTLD_NOW
);
1677 #define resolve(X) \
1678 if (!(p_##X = dlsym (dlhandle, #X))) \
1682 resolve (td_ta_new
);
1683 resolve (td_ta_delete
);
1685 resolve (td_ta_get_ph
);
1686 resolve (td_ta_get_nthreads
);
1687 resolve (td_ta_tsd_iter
);
1688 resolve (td_ta_thr_iter
);
1689 resolve (td_thr_validate
);
1690 resolve (td_thr_tsd
);
1691 resolve (td_thr_get_info
);
1692 resolve (td_thr_getfpregs
);
1693 resolve (td_thr_getxregsize
);
1694 resolve (td_thr_getxregs
);
1695 resolve (td_thr_sigsetmask
);
1696 resolve (td_thr_setprio
);
1697 resolve (td_thr_setsigpending
);
1698 resolve (td_thr_setfpregs
);
1699 resolve (td_thr_setxregs
);
1700 resolve (td_ta_map_id2thr
);
1701 resolve (td_ta_map_lwp2thr
);
1702 resolve (td_thr_getgregs
);
1703 resolve (td_thr_setgregs
);
1705 add_target (&sol_thread_ops
);
1707 procfs_suppress_run
= 1;
1709 add_cmd ("sol-threads", class_maintenance
, info_solthreads
,
1710 "Show info on Solaris user threads.\n", &maintenanceinfolist
);
1712 memcpy (&orig_core_ops
, &core_ops
, sizeof (struct target_ops
));
1713 memcpy (&core_ops
, &sol_core_ops
, sizeof (struct target_ops
));
1714 add_target (&core_ops
);
1716 /* Hook into new_objfile notification. */
1717 target_new_objfile_chain
= target_new_objfile_hook
;
1718 target_new_objfile_hook
= sol_thread_new_objfile
;
1723 fprintf_unfiltered (gdb_stderr
, "[GDB will not be able to debug user-mode threads: %s]\n", dlerror ());
1728 /* allow the user to debug non-threaded core files */
1729 add_target (&core_ops
);