1 /* Solaris threads debugging interface.
3 Copyright (C) 1996-2013 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 3 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, see <http://www.gnu.org/licenses/>. */
20 /* This module implements a sort of half target that sits between the
21 machine-independent parts of GDB and the /proc interface (procfs.c)
22 to provide access to the Solaris user-mode thread implementation.
24 Solaris threads are true user-mode threads, which are invoked via
25 the thr_* and pthread_* (native and POSIX respectivly) interfaces.
26 These are mostly implemented in user-space, with all thread context
27 kept in various structures that live in the user's heap. These
28 should not be confused with lightweight processes (LWPs), which are
29 implemented by the kernel, and scheduled without explicit
30 intervention by the process.
32 Just to confuse things a little, Solaris threads (both native and
33 POSIX) are actually implemented using LWPs. In general, there are
34 going to be more threads than LWPs. There is no fixed
35 correspondence between a thread and an LWP. When a thread wants to
36 run, it gets scheduled onto the first available LWP and can
37 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
41 called libthread_db.so.1 (not to be confused with
42 libthread_db.so.0, which doesn't have a published interface). This
43 interface has an upper part, which it provides, and a lower part
44 which we provide. The upper part consists of the td_* routines,
45 which allow us to find all the threads, query their state, etc...
46 The lower part consists of all of the ps_*, which are used by the
47 td_* routines to read/write memory, manipulate LWPs, lookup
48 symbols, etc... The ps_* routines actually do most of their work
49 by calling functions in procfs.c. */
53 #include <proc_service.h>
54 #include <thread_db.h>
55 #include "gdbthread.h"
67 #include "gdb_string.h"
70 struct target_ops sol_thread_ops;
72 /* Prototypes for supply_gregset etc. */
75 /* This struct is defined by us, but mainly used for the proc_service
76 interface. We don't have much use for it, except as a handy place
77 to get a real PID for memory accesses. */
90 static struct ps_prochandle main_ph;
91 static td_thragent_t *main_ta;
92 static int sol_thread_active = 0;
94 static void init_sol_thread_ops (void);
96 /* Default definitions: These must be defined in tm.h if they are to
97 be shared with a process module such as procfs. */
99 /* Pointers to routines from libthread_db resolved by dlopen(). */
101 static void (*p_td_log)(const int on_off);
102 static td_err_e (*p_td_ta_new)(const struct ps_prochandle *ph_p,
103 td_thragent_t **ta_pp);
104 static td_err_e (*p_td_ta_delete)(td_thragent_t *ta_p);
105 static td_err_e (*p_td_init)(void);
106 static td_err_e (*p_td_ta_get_ph)(const td_thragent_t *ta_p,
107 struct ps_prochandle **ph_pp);
108 static td_err_e (*p_td_ta_get_nthreads)(const td_thragent_t *ta_p,
110 static td_err_e (*p_td_ta_tsd_iter)(const td_thragent_t *ta_p,
111 td_key_iter_f *cb, void *cbdata_p);
112 static td_err_e (*p_td_ta_thr_iter)(const td_thragent_t *ta_p,
113 td_thr_iter_f *cb, void *cbdata_p,
114 td_thr_state_e state, int ti_pri,
115 sigset_t *ti_sigmask_p,
116 unsigned ti_user_flags);
117 static td_err_e (*p_td_thr_validate)(const td_thrhandle_t *th_p);
118 static td_err_e (*p_td_thr_tsd)(const td_thrhandle_t * th_p,
119 const thread_key_t key, void **data_pp);
120 static td_err_e (*p_td_thr_get_info)(const td_thrhandle_t *th_p,
122 static td_err_e (*p_td_thr_getfpregs)(const td_thrhandle_t *th_p,
123 prfpregset_t *fpregset);
124 static td_err_e (*p_td_thr_getxregsize)(const td_thrhandle_t *th_p,
126 static td_err_e (*p_td_thr_getxregs)(const td_thrhandle_t *th_p,
127 const caddr_t xregset);
128 static td_err_e (*p_td_thr_sigsetmask)(const td_thrhandle_t *th_p,
129 const sigset_t ti_sigmask);
130 static td_err_e (*p_td_thr_setprio)(const td_thrhandle_t *th_p,
132 static td_err_e (*p_td_thr_setsigpending)(const td_thrhandle_t *th_p,
133 const uchar_t ti_pending_flag,
134 const sigset_t ti_pending);
135 static td_err_e (*p_td_thr_setfpregs)(const td_thrhandle_t *th_p,
136 const prfpregset_t *fpregset);
137 static td_err_e (*p_td_thr_setxregs)(const td_thrhandle_t *th_p,
138 const caddr_t xregset);
139 static td_err_e (*p_td_ta_map_id2thr)(const td_thragent_t *ta_p,
141 td_thrhandle_t *th_p);
142 static td_err_e (*p_td_ta_map_lwp2thr)(const td_thragent_t *ta_p,
144 td_thrhandle_t *th_p);
145 static td_err_e (*p_td_thr_getgregs)(const td_thrhandle_t *th_p,
147 static td_err_e (*p_td_thr_setgregs)(const td_thrhandle_t *th_p,
148 const prgregset_t regset);
151 /* Return the libthread_db error string associated with ERRCODE. If
152 ERRCODE is unknown, return an appropriate message. */
155 td_err_string (td_err_e errcode)
157 static struct string_map td_err_table[] =
159 { TD_OK, "generic \"call succeeded\"" },
160 { TD_ERR, "generic error." },
161 { TD_NOTHR, "no thread can be found to satisfy query" },
162 { TD_NOSV, "no synch. variable can be found to satisfy query" },
163 { TD_NOLWP, "no lwp can be found to satisfy query" },
164 { TD_BADPH, "invalid process handle" },
165 { TD_BADTH, "invalid thread handle" },
166 { TD_BADSH, "invalid synchronization handle" },
167 { TD_BADTA, "invalid thread agent" },
168 { TD_BADKEY, "invalid key" },
169 { TD_NOMSG, "td_thr_event_getmsg() called when there was no message" },
170 { TD_NOFPREGS, "FPU register set not available for given thread" },
171 { TD_NOLIBTHREAD, "application not linked with libthread" },
172 { TD_NOEVENT, "requested event is not supported" },
173 { TD_NOCAPAB, "capability not available" },
174 { TD_DBERR, "Debugger service failed" },
175 { TD_NOAPLIC, "Operation not applicable to" },
176 { TD_NOTSD, "No thread specific data for this thread" },
177 { TD_MALLOC, "Malloc failed" },
178 { TD_PARTIALREG, "Only part of register set was written/read" },
179 { TD_NOXREGS, "X register set not available for given thread" }
181 const int td_err_size = sizeof td_err_table / sizeof (struct string_map);
185 for (i = 0; i < td_err_size; i++)
186 if (td_err_table[i].num == errcode)
187 return td_err_table[i].str;
189 xsnprintf (buf, sizeof (buf), "Unknown libthread_db error code: %d",
195 /* Return the libthread_db state string assicoated with STATECODE.
196 If STATECODE is unknown, return an appropriate message. */
199 td_state_string (td_thr_state_e statecode)
201 static struct string_map td_thr_state_table[] =
203 { TD_THR_ANY_STATE, "any state" },
204 { TD_THR_UNKNOWN, "unknown" },
205 { TD_THR_STOPPED, "stopped" },
206 { TD_THR_RUN, "run" },
207 { TD_THR_ACTIVE, "active" },
208 { TD_THR_ZOMBIE, "zombie" },
209 { TD_THR_SLEEP, "sleep" },
210 { TD_THR_STOPPED_ASLEEP, "stopped asleep" }
212 const int td_thr_state_table_size =
213 sizeof td_thr_state_table / sizeof (struct string_map);
217 for (i = 0; i < td_thr_state_table_size; i++)
218 if (td_thr_state_table[i].num == statecode)
219 return td_thr_state_table[i].str;
221 xsnprintf (buf, sizeof (buf), "Unknown libthread_db state code: %d",
228 /* Convert a POSIX or Solaris thread ID into a LWP ID. If THREAD_ID
229 doesn't exist, that's an error. If it's an inactive thread, return
232 NOTE: This function probably shouldn't call error(). */
235 thread_to_lwp (ptid_t thread_id, int default_lwp)
241 if (ptid_lwp_p (thread_id))
242 return thread_id; /* It's already an LWP ID. */
244 /* It's a thread. Convert to LWP. */
246 val = p_td_ta_map_id2thr (main_ta, ptid_get_tid (thread_id), &th);
248 return pid_to_ptid (-1); /* Thread must have terminated. */
249 else if (val != TD_OK)
250 error (_("thread_to_lwp: td_ta_map_id2thr %s"), td_err_string (val));
252 val = p_td_thr_get_info (&th, &ti);
254 return pid_to_ptid (-1); /* Thread must have terminated. */
255 else if (val != TD_OK)
256 error (_("thread_to_lwp: td_thr_get_info: %s"), td_err_string (val));
258 if (ti.ti_state != TD_THR_ACTIVE)
260 if (default_lwp != -1)
261 return pid_to_ptid (default_lwp);
262 error (_("thread_to_lwp: thread state not active: %s"),
263 td_state_string (ti.ti_state));
266 return ptid_build (ptid_get_pid (thread_id), ti.ti_lid, 0);
269 /* Convert an LWP ID into a POSIX or Solaris thread ID. If LWP_ID
270 doesn't exists, that's an error.
272 NOTE: This function probably shouldn't call error(). */
275 lwp_to_thread (ptid_t lwp)
281 if (ptid_tid_p (lwp))
282 return lwp; /* It's already a thread ID. */
284 /* It's an LWP. Convert it to a thread ID. */
286 if (!target_thread_alive (lwp))
287 return pid_to_ptid (-1); /* Must be a defunct LPW. */
289 val = p_td_ta_map_lwp2thr (main_ta, ptid_get_lwp (lwp), &th);
291 return pid_to_ptid (-1); /* Thread must have terminated. */
292 else if (val != TD_OK)
293 error (_("lwp_to_thread: td_ta_map_lwp2thr: %s."), td_err_string (val));
295 val = p_td_thr_validate (&th);
297 return lwp; /* Unknown to libthread; just return LPW, */
298 else if (val != TD_OK)
299 error (_("lwp_to_thread: td_thr_validate: %s."), td_err_string (val));
301 val = p_td_thr_get_info (&th, &ti);
303 return pid_to_ptid (-1); /* Thread must have terminated. */
304 else if (val != TD_OK)
305 error (_("lwp_to_thread: td_thr_get_info: %s."), td_err_string (val));
307 return ptid_build (ptid_get_pid (lwp), 0 , ti.ti_tid);
311 /* Most target vector functions from here on actually just pass
312 through to the layer beneath, as they don't need to do anything
313 specific for threads. */
315 /* Take a program previously attached to and detaches it. The program
316 resumes execution and will no longer stop on signals, etc. We'd
317 better not have left any breakpoints in the program or it'll die
318 when it hits one. For this to work, it may be necessary for the
319 process to have been previously attached. It *might* work if the
320 program was started via the normal ptrace (PTRACE_TRACEME). */
323 sol_thread_detach (struct target_ops *ops, const char *args, int from_tty)
325 struct target_ops *beneath = find_target_beneath (ops);
327 sol_thread_active = 0;
328 inferior_ptid = pid_to_ptid (ptid_get_pid (main_ph.ptid));
330 beneath->to_detach (beneath, args, from_tty);
333 /* Resume execution of process PTID. If STEP is nozero, then just
334 single step it. If SIGNAL is nonzero, restart it with that signal
335 activated. We may have to convert PTID from a thread ID to an LWP
339 sol_thread_resume (struct target_ops *ops,
340 ptid_t ptid, int step, enum gdb_signal signo)
342 struct cleanup *old_chain;
343 struct target_ops *beneath = find_target_beneath (ops);
345 old_chain = save_inferior_ptid ();
347 inferior_ptid = thread_to_lwp (inferior_ptid, ptid_get_pid (main_ph.ptid));
348 if (ptid_get_pid (inferior_ptid) == -1)
349 inferior_ptid = procfs_first_available ();
351 if (ptid_get_pid (ptid) != -1)
353 ptid_t save_ptid = ptid;
355 ptid = thread_to_lwp (ptid, -2);
356 if (ptid_get_pid (ptid) == -2) /* Inactive thread. */
357 error (_("This version of Solaris can't start inactive threads."));
358 if (info_verbose && ptid_get_pid (ptid) == -1)
359 warning (_("Specified thread %ld seems to have terminated"),
360 ptid_get_tid (save_ptid));
363 beneath->to_resume (beneath, ptid, step, signo);
365 do_cleanups (old_chain);
368 /* Wait for any threads to stop. We may have to convert PTID from a
369 thread ID to an LWP ID, and vice versa on the way out. */
372 sol_thread_wait (struct target_ops *ops,
373 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
377 struct target_ops *beneath = find_target_beneath (ops);
378 struct cleanup *old_chain;
380 save_ptid = inferior_ptid;
381 old_chain = save_inferior_ptid ();
383 inferior_ptid = thread_to_lwp (inferior_ptid, ptid_get_pid (main_ph.ptid));
384 if (ptid_get_pid (inferior_ptid) == -1)
385 inferior_ptid = procfs_first_available ();
387 if (ptid_get_pid (ptid) != -1)
389 ptid_t save_ptid = ptid;
391 ptid = thread_to_lwp (ptid, -2);
392 if (ptid_get_pid (ptid) == -2) /* Inactive thread. */
393 error (_("This version of Solaris can't start inactive threads."));
394 if (info_verbose && ptid_get_pid (ptid) == -1)
395 warning (_("Specified thread %ld seems to have terminated"),
396 ptid_get_tid (save_ptid));
399 rtnval = beneath->to_wait (beneath, ptid, ourstatus, options);
401 if (ourstatus->kind != TARGET_WAITKIND_EXITED)
403 /* Map the LWP of interest back to the appropriate thread ID. */
404 rtnval = lwp_to_thread (rtnval);
405 if (ptid_get_pid (rtnval) == -1)
408 /* See if we have a new thread. */
409 if (ptid_tid_p (rtnval)
410 && !ptid_equal (rtnval, save_ptid)
411 && (!in_thread_list (rtnval)
412 || is_exited (rtnval)))
416 /* During process initialization, we may get here without the thread
417 package being initialized, since that can only happen after we've
418 found the shared libs. */
420 do_cleanups (old_chain);
426 sol_thread_fetch_registers (struct target_ops *ops,
427 struct regcache *regcache, int regnum)
430 td_thrhandle_t thandle;
433 prfpregset_t fpregset;
434 gdb_gregset_t *gregset_p = &gregset;
435 gdb_fpregset_t *fpregset_p = &fpregset;
436 struct target_ops *beneath = find_target_beneath (ops);
438 if (!ptid_tid_p (inferior_ptid))
440 /* It's an LWP; pass the request on to the layer beneath. */
441 beneath->to_fetch_registers (beneath, regcache, regnum);
445 /* Solaris thread: convert INFERIOR_PTID into a td_thrhandle_t. */
446 thread = ptid_get_tid (inferior_ptid);
448 error (_("sol_thread_fetch_registers: thread == 0"));
450 val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
452 error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"),
453 td_err_string (val));
455 /* Get the general-purpose registers. */
457 val = p_td_thr_getgregs (&thandle, gregset);
458 if (val != TD_OK && val != TD_PARTIALREG)
459 error (_("sol_thread_fetch_registers: td_thr_getgregs %s"),
460 td_err_string (val));
462 /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
463 and %sp are saved (by a thread context switch). */
465 /* And, now the floating-point registers. */
467 val = p_td_thr_getfpregs (&thandle, &fpregset);
468 if (val != TD_OK && val != TD_NOFPREGS)
469 error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"),
470 td_err_string (val));
472 /* Note that we must call supply_gregset and supply_fpregset *after*
473 calling the td routines because the td routines call ps_lget*
474 which affect the values stored in the registers array. */
476 supply_gregset (regcache, (const gdb_gregset_t *) gregset_p);
477 supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset_p);
481 sol_thread_store_registers (struct target_ops *ops,
482 struct regcache *regcache, int regnum)
485 td_thrhandle_t thandle;
488 prfpregset_t fpregset;
490 if (!ptid_tid_p (inferior_ptid))
492 struct target_ops *beneath = find_target_beneath (ops);
494 /* It's an LWP; pass the request on to the layer beneath. */
495 beneath->to_store_registers (beneath, regcache, regnum);
499 /* Solaris thread: convert INFERIOR_PTID into a td_thrhandle_t. */
500 thread = ptid_get_tid (inferior_ptid);
502 val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
504 error (_("sol_thread_store_registers: td_ta_map_id2thr %s"),
505 td_err_string (val));
509 /* Not writing all the registers. */
510 char old_value[MAX_REGISTER_SIZE];
512 /* Save new register value. */
513 regcache_raw_collect (regcache, regnum, old_value);
515 val = p_td_thr_getgregs (&thandle, gregset);
517 error (_("sol_thread_store_registers: td_thr_getgregs %s"),
518 td_err_string (val));
519 val = p_td_thr_getfpregs (&thandle, &fpregset);
521 error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
522 td_err_string (val));
524 /* Restore new register value. */
525 regcache_raw_supply (regcache, regnum, old_value);
528 fill_gregset (regcache, (gdb_gregset_t *) &gregset, regnum);
529 fill_fpregset (regcache, (gdb_fpregset_t *) &fpregset, regnum);
531 val = p_td_thr_setgregs (&thandle, gregset);
533 error (_("sol_thread_store_registers: td_thr_setgregs %s"),
534 td_err_string (val));
535 val = p_td_thr_setfpregs (&thandle, &fpregset);
537 error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
538 td_err_string (val));
541 /* Perform partial transfers on OBJECT. See target_read_partial and
542 target_write_partial for details of each variant. One, and only
543 one, of readbuf or writebuf must be non-NULL. */
546 sol_thread_xfer_partial (struct target_ops *ops, enum target_object object,
547 const char *annex, gdb_byte *readbuf,
548 const gdb_byte *writebuf,
549 ULONGEST offset, LONGEST len)
552 struct cleanup *old_chain;
553 struct target_ops *beneath = find_target_beneath (ops);
555 old_chain = save_inferior_ptid ();
557 if (ptid_tid_p (inferior_ptid) || !target_thread_alive (inferior_ptid))
559 /* It's either a thread or an LWP that isn't alive. Any live
560 LWP will do so use the first available.
562 NOTE: We don't need to call switch_to_thread; we're just
564 inferior_ptid = procfs_first_available ();
567 retval = beneath->to_xfer_partial (beneath, object, annex,
568 readbuf, writebuf, offset, len);
570 do_cleanups (old_chain);
576 check_for_thread_db (void)
581 /* Do nothing if we couldn't load libthread_db.so.1. */
582 if (p_td_ta_new == NULL)
585 if (sol_thread_active)
586 /* Nothing to do. The thread library was already detected and the
587 target vector was already activated. */
590 /* Now, initialize libthread_db. This needs to be done after the
591 shared libraries are located because it needs information from
592 the user's thread library. */
597 warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (err));
601 /* Now attempt to open a connection to the thread library. */
602 err = p_td_ta_new (&main_ph, &main_ta);
606 /* No thread library was detected. */
610 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
612 /* The thread library was detected. Activate the sol_thread target. */
613 push_target (&sol_thread_ops);
614 sol_thread_active = 1;
616 main_ph.ptid = inferior_ptid; /* Save for xfer_memory. */
617 ptid = lwp_to_thread (inferior_ptid);
618 if (ptid_get_pid (ptid) != -1)
619 inferior_ptid = ptid;
621 target_find_new_threads ();
625 warning (_("Cannot initialize thread debugging library: %s"),
626 td_err_string (err));
631 /* This routine is called whenever a new symbol table is read in, or
632 when all symbol tables are removed. libthread_db can only be
633 initialized when it finds the right variables in libthread.so.
634 Since it's a shared library, those variables don't show up until
635 the library gets mapped and the symbol table is read in. */
638 sol_thread_new_objfile (struct objfile *objfile)
641 check_for_thread_db ();
644 /* Clean up after the inferior dies. */
647 sol_thread_mourn_inferior (struct target_ops *ops)
649 struct target_ops *beneath = find_target_beneath (ops);
651 sol_thread_active = 0;
655 beneath->to_mourn_inferior (beneath);
658 /* Return true if PTID is still active in the inferior. */
661 sol_thread_alive (struct target_ops *ops, ptid_t ptid)
663 if (ptid_tid_p (ptid))
665 /* It's a (user-level) thread. */
670 pid = ptid_get_tid (ptid);
671 if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK)
672 return 0; /* Thread not found. */
673 if ((val = p_td_thr_validate (&th)) != TD_OK)
674 return 0; /* Thread not valid. */
675 return 1; /* Known thread. */
679 struct target_ops *beneath = find_target_beneath (ops);
681 /* It's an LPW; pass the request on to the layer below. */
682 return beneath->to_thread_alive (beneath, ptid);
687 /* These routines implement the lower half of the thread_db interface,
688 i.e. the ps_* routines. */
690 /* Various versions of <proc_service.h> have slightly different
691 function prototypes. In particular, we have
694 struct ps_prochandle * const struct ps_prochandle *
699 Which one you have depends on the Solaris version and what patches
700 you've applied. On the theory that there are only two major
701 variants, we have configure check the prototype of ps_pdwrite (),
702 and use that info to make appropriate typedefs here. */
704 #ifdef PROC_SERVICE_IS_OLD
705 typedef const struct ps_prochandle *gdb_ps_prochandle_t;
706 typedef char *gdb_ps_read_buf_t;
707 typedef char *gdb_ps_write_buf_t;
708 typedef int gdb_ps_size_t;
709 typedef psaddr_t gdb_ps_addr_t;
711 typedef struct ps_prochandle *gdb_ps_prochandle_t;
712 typedef void *gdb_ps_read_buf_t;
713 typedef const void *gdb_ps_write_buf_t;
714 typedef size_t gdb_ps_size_t;
715 typedef psaddr_t gdb_ps_addr_t;
718 /* The next four routines are called by libthread_db to tell us to
719 stop and stop a particular process or lwp. Since GDB ensures that
720 these are all stopped by the time we call anything in thread_db,
721 these routines need to do nothing. */
726 ps_pstop (gdb_ps_prochandle_t ph)
731 /* Process continue. */
734 ps_pcontinue (gdb_ps_prochandle_t ph)
742 ps_lstop (gdb_ps_prochandle_t ph, lwpid_t lwpid)
750 ps_lcontinue (gdb_ps_prochandle_t ph, lwpid_t lwpid)
755 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
758 ps_pglobal_lookup (gdb_ps_prochandle_t ph, const char *ld_object_name,
759 const char *ld_symbol_name, gdb_ps_addr_t *ld_symbol_addr)
761 struct minimal_symbol *ms;
763 ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL);
767 *ld_symbol_addr = SYMBOL_VALUE_ADDRESS (ms);
771 /* Common routine for reading and writing memory. */
774 rw_common (int dowrite, const struct ps_prochandle *ph, gdb_ps_addr_t addr,
775 gdb_byte *buf, int size)
778 struct cleanup *old_chain;
780 old_chain = save_inferior_ptid ();
782 if (ptid_tid_p (inferior_ptid) || !target_thread_alive (inferior_ptid))
784 /* It's either a thread or an LWP that isn't alive. Any live
785 LWP will do so use the first available.
787 NOTE: We don't need to call switch_to_thread; we're just
789 inferior_ptid = procfs_first_available ();
792 #if defined (__sparcv9)
793 /* For Sparc64 cross Sparc32, make sure the address has not been
794 accidentally sign-extended (or whatever) to beyond 32 bits. */
795 if (bfd_get_arch_size (exec_bfd) == 32)
800 ret = target_write_memory (addr, (gdb_byte *) buf, size);
802 ret = target_read_memory (addr, (gdb_byte *) buf, size);
804 do_cleanups (old_chain);
806 return (ret == 0 ? PS_OK : PS_ERR);
809 /* Copies SIZE bytes from target process .data segment to debugger memory. */
812 ps_pdread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
813 gdb_ps_read_buf_t buf, gdb_ps_size_t size)
815 return rw_common (0, ph, addr, buf, size);
818 /* Copies SIZE bytes from debugger memory .data segment to target process. */
821 ps_pdwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
822 gdb_ps_write_buf_t buf, gdb_ps_size_t size)
824 return rw_common (1, ph, addr, (gdb_byte *) buf, size);
827 /* Copies SIZE bytes from target process .text segment to debugger memory. */
830 ps_ptread (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
831 gdb_ps_read_buf_t buf, gdb_ps_size_t size)
833 return rw_common (0, ph, addr, buf, size);
836 /* Copies SIZE bytes from debugger memory .text segment to target process. */
839 ps_ptwrite (gdb_ps_prochandle_t ph, gdb_ps_addr_t addr,
840 gdb_ps_write_buf_t buf, gdb_ps_size_t size)
842 return rw_common (1, ph, addr, (gdb_byte *) buf, size);
845 /* Get general-purpose registers for LWP. */
848 ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset)
850 struct cleanup *old_chain;
851 struct regcache *regcache;
853 old_chain = save_inferior_ptid ();
855 inferior_ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
856 regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
858 target_fetch_registers (regcache, -1);
859 fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
861 do_cleanups (old_chain);
866 /* Set general-purpose registers for LWP. */
869 ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
870 const prgregset_t gregset)
872 struct cleanup *old_chain;
873 struct regcache *regcache;
875 old_chain = save_inferior_ptid ();
877 inferior_ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
878 regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
880 supply_gregset (regcache, (const gdb_gregset_t *) gregset);
881 target_store_registers (regcache, -1);
883 do_cleanups (old_chain);
888 /* Log a message (sends to gdb_stderr). */
891 ps_plog (const char *fmt, ...)
895 va_start (args, fmt);
897 vfprintf_filtered (gdb_stderr, fmt, args);
900 /* Get size of extra register set. Currently a noop. */
903 ps_lgetxregsize (gdb_ps_prochandle_t ph, lwpid_t lwpid, int *xregsize)
908 /* Get extra register set. Currently a noop. */
911 ps_lgetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset)
916 /* Set extra register set. Currently a noop. */
919 ps_lsetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset)
924 /* Get floating-point registers for LWP. */
927 ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
928 prfpregset_t *fpregset)
930 struct cleanup *old_chain;
931 struct regcache *regcache;
933 old_chain = save_inferior_ptid ();
935 inferior_ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
936 regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
938 target_fetch_registers (regcache, -1);
939 fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
941 do_cleanups (old_chain);
946 /* Set floating-point regs for LWP. */
949 ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid,
950 const prfpregset_t * fpregset)
952 struct cleanup *old_chain;
953 struct regcache *regcache;
955 old_chain = save_inferior_ptid ();
957 inferior_ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
958 regcache = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
960 supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
961 target_store_registers (regcache, -1);
963 do_cleanups (old_chain);
969 /* Identify process as 32-bit or 64-bit. At the moment we're using
970 BFD to do this. There might be a more Solaris-specific
971 (e.g. procfs) method, but this ought to work. */
974 ps_pdmodel (gdb_ps_prochandle_t ph, int *data_model)
977 *data_model = PR_MODEL_UNKNOWN;
978 else if (bfd_get_arch_size (exec_bfd) == 32)
979 *data_model = PR_MODEL_ILP32;
981 *data_model = PR_MODEL_LP64;
985 #endif /* PR_MODEL_LP64 */
987 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
989 /* Reads the local descriptor table of a LWP.
991 This function is necessary on x86-solaris only. Without it, the loading
992 of libthread_db would fail because of ps_lgetLDT being undefined. */
995 ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid,
998 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */
1001 /* FIXME: can't I get the process ID from the prochandle or
1004 if (ptid_get_pid (inferior_ptid) <= 0 || lwpid <= 0)
1007 ret = procfs_find_LDT_entry (ptid_build (ptid_get_pid (inferior_ptid),
1011 memcpy (pldt, ret, sizeof (struct ssd));
1015 /* LDT not found. */
1021 /* Convert PTID to printable form. */
1024 solaris_pid_to_str (struct target_ops *ops, ptid_t ptid)
1026 static char buf[100];
1028 if (ptid_tid_p (ptid))
1032 lwp = thread_to_lwp (ptid, -2);
1034 if (ptid_get_pid (lwp) == -1)
1035 xsnprintf (buf, sizeof (buf), "Thread %ld (defunct)",
1036 ptid_get_tid (ptid));
1037 else if (ptid_get_pid (lwp) != -2)
1038 xsnprintf (buf, sizeof (buf), "Thread %ld (LWP %ld)",
1039 ptid_get_tid (ptid), ptid_get_lwp (lwp));
1041 xsnprintf (buf, sizeof (buf), "Thread %ld ",
1042 ptid_get_tid (ptid));
1044 else if (ptid_get_lwp (ptid) != 0)
1045 xsnprintf (buf, sizeof (buf), "LWP %ld ", ptid_get_lwp (ptid));
1047 xsnprintf (buf, sizeof (buf), "process %d ", ptid_get_pid (ptid));
1053 /* Worker bee for find_new_threads. Callback function that gets
1054 called once per user-level thread (i.e. not for LWP's). */
1057 sol_find_new_threads_callback (const td_thrhandle_t *th, void *ignored)
1063 retval = p_td_thr_get_info (th, &ti);
1064 if (retval != TD_OK)
1067 ptid = ptid_build (ptid_get_pid (inferior_ptid), 0, ti.ti_tid);
1068 if (!in_thread_list (ptid) || is_exited (ptid))
1075 sol_find_new_threads (struct target_ops *ops)
1077 struct target_ops *beneath = find_target_beneath (ops);
1079 /* First Find any new LWP's. */
1080 if (beneath->to_find_new_threads != NULL)
1081 beneath->to_find_new_threads (beneath);
1083 /* Then find any new user-level threads. */
1084 p_td_ta_thr_iter (main_ta, sol_find_new_threads_callback, (void *) 0,
1085 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1086 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1089 /* Worker bee for the "info sol-thread" command. This is a callback
1090 function that gets called once for each Solaris user-level thread
1091 (i.e. not for LWPs) in the inferior. Print anything interesting
1092 that we can think of. */
1095 info_cb (const td_thrhandle_t *th, void *s)
1100 ret = p_td_thr_get_info (th, &ti);
1103 printf_filtered ("%s thread #%d, lwp %d, ",
1104 ti.ti_type == TD_THR_SYSTEM ? "system" : "user ",
1105 ti.ti_tid, ti.ti_lid);
1106 switch (ti.ti_state)
1109 case TD_THR_UNKNOWN:
1110 printf_filtered ("<unknown state>");
1112 case TD_THR_STOPPED:
1113 printf_filtered ("(stopped)");
1116 printf_filtered ("(run) ");
1119 printf_filtered ("(active) ");
1122 printf_filtered ("(zombie) ");
1125 printf_filtered ("(asleep) ");
1127 case TD_THR_STOPPED_ASLEEP:
1128 printf_filtered ("(stopped asleep)");
1131 /* Print thr_create start function. */
1132 if (ti.ti_startfunc != 0)
1134 const struct bound_minimal_symbol msym
1135 = lookup_minimal_symbol_by_pc (ti.ti_startfunc);
1137 printf_filtered (" startfunc=%s",
1139 ? SYMBOL_PRINT_NAME (msym.minsym)
1140 : paddress (target_gdbarch (), ti.ti_startfunc));
1143 /* If thread is asleep, print function that went to sleep. */
1144 if (ti.ti_state == TD_THR_SLEEP)
1146 const struct bound_minimal_symbol msym
1147 = lookup_minimal_symbol_by_pc (ti.ti_pc);
1149 printf_filtered (" sleepfunc=%s",
1151 ? SYMBOL_PRINT_NAME (msym.minsym)
1152 : paddress (target_gdbarch (), ti.ti_pc));
1155 printf_filtered ("\n");
1158 warning (_("info sol-thread: failed to get info for thread."));
1163 /* List some state about each Solaris user-level thread in the
1167 info_solthreads (char *args, int from_tty)
1169 p_td_ta_thr_iter (main_ta, info_cb, args,
1170 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1171 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1174 /* Callback routine used to find a thread based on the TID part of
1178 thread_db_find_thread_from_tid (struct thread_info *thread, void *data)
1180 long *tid = (long *) data;
1182 if (ptid_get_tid (thread->ptid) == *tid)
1189 sol_get_ada_task_ptid (long lwp, long thread)
1191 struct thread_info *thread_info =
1192 iterate_over_threads (thread_db_find_thread_from_tid, &thread);
1194 if (thread_info == NULL)
1196 /* The list of threads is probably not up to date. Find any
1197 thread that is missing from the list, and try again. */
1198 sol_find_new_threads (¤t_target);
1199 thread_info = iterate_over_threads (thread_db_find_thread_from_tid,
1203 gdb_assert (thread_info != NULL);
1205 return (thread_info->ptid);
1209 init_sol_thread_ops (void)
1211 sol_thread_ops.to_shortname = "solaris-threads";
1212 sol_thread_ops.to_longname = "Solaris threads and pthread.";
1213 sol_thread_ops.to_doc = "Solaris threads and pthread support.";
1214 sol_thread_ops.to_detach = sol_thread_detach;
1215 sol_thread_ops.to_resume = sol_thread_resume;
1216 sol_thread_ops.to_wait = sol_thread_wait;
1217 sol_thread_ops.to_fetch_registers = sol_thread_fetch_registers;
1218 sol_thread_ops.to_store_registers = sol_thread_store_registers;
1219 sol_thread_ops.to_xfer_partial = sol_thread_xfer_partial;
1220 sol_thread_ops.to_mourn_inferior = sol_thread_mourn_inferior;
1221 sol_thread_ops.to_thread_alive = sol_thread_alive;
1222 sol_thread_ops.to_pid_to_str = solaris_pid_to_str;
1223 sol_thread_ops.to_find_new_threads = sol_find_new_threads;
1224 sol_thread_ops.to_stratum = thread_stratum;
1225 sol_thread_ops.to_get_ada_task_ptid = sol_get_ada_task_ptid;
1226 sol_thread_ops.to_magic = OPS_MAGIC;
1229 /* Silence -Wmissing-prototypes. */
1230 extern void _initialize_sol_thread (void);
1233 _initialize_sol_thread (void)
1237 init_sol_thread_ops ();
1239 dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW);
1243 #define resolve(X) \
1244 if (!(p_##X = dlsym (dlhandle, #X))) \
1248 resolve (td_ta_new);
1249 resolve (td_ta_delete);
1251 resolve (td_ta_get_ph);
1252 resolve (td_ta_get_nthreads);
1253 resolve (td_ta_tsd_iter);
1254 resolve (td_ta_thr_iter);
1255 resolve (td_thr_validate);
1256 resolve (td_thr_tsd);
1257 resolve (td_thr_get_info);
1258 resolve (td_thr_getfpregs);
1259 resolve (td_thr_getxregsize);
1260 resolve (td_thr_getxregs);
1261 resolve (td_thr_sigsetmask);
1262 resolve (td_thr_setprio);
1263 resolve (td_thr_setsigpending);
1264 resolve (td_thr_setfpregs);
1265 resolve (td_thr_setxregs);
1266 resolve (td_ta_map_id2thr);
1267 resolve (td_ta_map_lwp2thr);
1268 resolve (td_thr_getgregs);
1269 resolve (td_thr_setgregs);
1271 complete_target_initialization (&sol_thread_ops);
1273 add_cmd ("sol-threads", class_maintenance, info_solthreads,
1274 _("Show info on Solaris user threads."), &maintenanceinfolist);
1276 /* Hook into new_objfile notification. */
1277 observer_attach_new_objfile (sol_thread_new_objfile);
1281 fprintf_unfiltered (gdb_stderr, "\
1282 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ());