1 /* Solaris threads debugging interface.
3 Copyright (C) 1996-2018 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"
66 #include "observable.h"
72 static const target_info thread_db_target_info = {
74 N_("Solaris threads and pthread."),
75 N_("Solaris threads and pthread support.")
78 class sol_thread_target final : public target_ops
82 { this->to_stratum = thread_stratum; }
84 const target_info &info () const override
85 { return thread_db_target_info; }
87 void detach (inferior *, int) override;
88 ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
89 void resume (ptid_t, int, enum gdb_signal) override;
90 void mourn_inferior () override;
91 const char *pid_to_str (ptid_t) override;
92 ptid_t get_ada_task_ptid (long lwp, long thread) override;
94 void fetch_registers (struct regcache *, int) override;
95 void store_registers (struct regcache *, int) override;
97 enum target_xfer_status xfer_partial (enum target_object object,
100 const gdb_byte *writebuf,
101 ULONGEST offset, ULONGEST len,
102 ULONGEST *xfered_len) override;
104 bool thread_alive (ptid_t ptid) override;
105 void update_thread_list () override;
108 static sol_thread_target sol_thread_ops;
110 /* Prototypes for supply_gregset etc. */
113 /* This struct is defined by us, but mainly used for the proc_service
114 interface. We don't have much use for it, except as a handy place
115 to get a real PID for memory accesses. */
128 static struct ps_prochandle main_ph;
129 static td_thragent_t *main_ta;
130 static int sol_thread_active = 0;
132 /* Default definitions: These must be defined in tm.h if they are to
133 be shared with a process module such as procfs. */
135 /* Types of the libthread_db functions. */
137 typedef void (td_log_ftype)(const int on_off);
138 typedef td_err_e (td_ta_new_ftype)(const struct ps_prochandle *ph_p,
139 td_thragent_t **ta_pp);
140 typedef td_err_e (td_ta_delete_ftype)(td_thragent_t *ta_p);
141 typedef td_err_e (td_init_ftype)(void);
142 typedef td_err_e (td_ta_get_ph_ftype)(const td_thragent_t *ta_p,
143 struct ps_prochandle **ph_pp);
144 typedef td_err_e (td_ta_get_nthreads_ftype)(const td_thragent_t *ta_p,
146 typedef td_err_e (td_ta_tsd_iter_ftype)(const td_thragent_t *ta_p,
147 td_key_iter_f *cb, void *cbdata_p);
148 typedef td_err_e (td_ta_thr_iter_ftype)(const td_thragent_t *ta_p,
149 td_thr_iter_f *cb, void *cbdata_p,
150 td_thr_state_e state, int ti_pri,
151 sigset_t *ti_sigmask_p,
152 unsigned ti_user_flags);
153 typedef td_err_e (td_thr_validate_ftype)(const td_thrhandle_t *th_p);
154 typedef td_err_e (td_thr_tsd_ftype)(const td_thrhandle_t * th_p,
155 const thread_key_t key, void **data_pp);
156 typedef td_err_e (td_thr_get_info_ftype)(const td_thrhandle_t *th_p,
158 typedef td_err_e (td_thr_getfpregs_ftype)(const td_thrhandle_t *th_p,
159 prfpregset_t *fpregset);
160 typedef td_err_e (td_thr_getxregsize_ftype)(const td_thrhandle_t *th_p,
162 typedef td_err_e (td_thr_getxregs_ftype)(const td_thrhandle_t *th_p,
163 const caddr_t xregset);
164 typedef td_err_e (td_thr_sigsetmask_ftype)(const td_thrhandle_t *th_p,
165 const sigset_t ti_sigmask);
166 typedef td_err_e (td_thr_setprio_ftype)(const td_thrhandle_t *th_p,
168 typedef td_err_e (td_thr_setsigpending_ftype)(const td_thrhandle_t *th_p,
169 const uchar_t ti_pending_flag,
170 const sigset_t ti_pending);
171 typedef td_err_e (td_thr_setfpregs_ftype)(const td_thrhandle_t *th_p,
172 const prfpregset_t *fpregset);
173 typedef td_err_e (td_thr_setxregs_ftype)(const td_thrhandle_t *th_p,
174 const caddr_t xregset);
175 typedef td_err_e (td_ta_map_id2thr_ftype)(const td_thragent_t *ta_p,
177 td_thrhandle_t *th_p);
178 typedef td_err_e (td_ta_map_lwp2thr_ftype)(const td_thragent_t *ta_p,
180 td_thrhandle_t *th_p);
181 typedef td_err_e (td_thr_getgregs_ftype)(const td_thrhandle_t *th_p,
183 typedef td_err_e (td_thr_setgregs_ftype)(const td_thrhandle_t *th_p,
184 const prgregset_t regset);
186 /* Pointers to routines from libthread_db resolved by dlopen(). */
188 static td_log_ftype *p_td_log;
189 static td_ta_new_ftype *p_td_ta_new;
190 static td_ta_delete_ftype *p_td_ta_delete;
191 static td_init_ftype *p_td_init;
192 static td_ta_get_ph_ftype *p_td_ta_get_ph;
193 static td_ta_get_nthreads_ftype *p_td_ta_get_nthreads;
194 static td_ta_tsd_iter_ftype *p_td_ta_tsd_iter;
195 static td_ta_thr_iter_ftype *p_td_ta_thr_iter;
196 static td_thr_validate_ftype *p_td_thr_validate;
197 static td_thr_tsd_ftype *p_td_thr_tsd;
198 static td_thr_get_info_ftype *p_td_thr_get_info;
199 static td_thr_getfpregs_ftype *p_td_thr_getfpregs;
200 static td_thr_getxregsize_ftype *p_td_thr_getxregsize;
201 static td_thr_getxregs_ftype *p_td_thr_getxregs;
202 static td_thr_sigsetmask_ftype *p_td_thr_sigsetmask;
203 static td_thr_setprio_ftype *p_td_thr_setprio;
204 static td_thr_setsigpending_ftype *p_td_thr_setsigpending;
205 static td_thr_setfpregs_ftype *p_td_thr_setfpregs;
206 static td_thr_setxregs_ftype *p_td_thr_setxregs;
207 static td_ta_map_id2thr_ftype *p_td_ta_map_id2thr;
208 static td_ta_map_lwp2thr_ftype *p_td_ta_map_lwp2thr;
209 static td_thr_getgregs_ftype *p_td_thr_getgregs;
210 static td_thr_setgregs_ftype *p_td_thr_setgregs;
213 /* Return the libthread_db error string associated with ERRCODE. If
214 ERRCODE is unknown, return an appropriate message. */
217 td_err_string (td_err_e errcode)
219 static struct string_map td_err_table[] =
221 { TD_OK, "generic \"call succeeded\"" },
222 { TD_ERR, "generic error." },
223 { TD_NOTHR, "no thread can be found to satisfy query" },
224 { TD_NOSV, "no synch. variable can be found to satisfy query" },
225 { TD_NOLWP, "no lwp can be found to satisfy query" },
226 { TD_BADPH, "invalid process handle" },
227 { TD_BADTH, "invalid thread handle" },
228 { TD_BADSH, "invalid synchronization handle" },
229 { TD_BADTA, "invalid thread agent" },
230 { TD_BADKEY, "invalid key" },
231 { TD_NOMSG, "td_thr_event_getmsg() called when there was no message" },
232 { TD_NOFPREGS, "FPU register set not available for given thread" },
233 { TD_NOLIBTHREAD, "application not linked with libthread" },
234 { TD_NOEVENT, "requested event is not supported" },
235 { TD_NOCAPAB, "capability not available" },
236 { TD_DBERR, "Debugger service failed" },
237 { TD_NOAPLIC, "Operation not applicable to" },
238 { TD_NOTSD, "No thread specific data for this thread" },
239 { TD_MALLOC, "Malloc failed" },
240 { TD_PARTIALREG, "Only part of register set was written/read" },
241 { TD_NOXREGS, "X register set not available for given thread" }
243 const int td_err_size = sizeof td_err_table / sizeof (struct string_map);
247 for (i = 0; i < td_err_size; i++)
248 if (td_err_table[i].num == errcode)
249 return td_err_table[i].str;
251 xsnprintf (buf, sizeof (buf), "Unknown libthread_db error code: %d",
257 /* Return the libthread_db state string assicoated with STATECODE.
258 If STATECODE is unknown, return an appropriate message. */
261 td_state_string (td_thr_state_e statecode)
263 static struct string_map td_thr_state_table[] =
265 { TD_THR_ANY_STATE, "any state" },
266 { TD_THR_UNKNOWN, "unknown" },
267 { TD_THR_STOPPED, "stopped" },
268 { TD_THR_RUN, "run" },
269 { TD_THR_ACTIVE, "active" },
270 { TD_THR_ZOMBIE, "zombie" },
271 { TD_THR_SLEEP, "sleep" },
272 { TD_THR_STOPPED_ASLEEP, "stopped asleep" }
274 const int td_thr_state_table_size =
275 sizeof td_thr_state_table / sizeof (struct string_map);
279 for (i = 0; i < td_thr_state_table_size; i++)
280 if (td_thr_state_table[i].num == statecode)
281 return td_thr_state_table[i].str;
283 xsnprintf (buf, sizeof (buf), "Unknown libthread_db state code: %d",
290 /* Convert a POSIX or Solaris thread ID into a LWP ID. If THREAD_ID
291 doesn't exist, that's an error. If it's an inactive thread, return
294 NOTE: This function probably shouldn't call error(). */
297 thread_to_lwp (ptid_t thread_id, int default_lwp)
303 if (ptid_lwp_p (thread_id))
304 return thread_id; /* It's already an LWP ID. */
306 /* It's a thread. Convert to LWP. */
308 val = p_td_ta_map_id2thr (main_ta, ptid_get_tid (thread_id), &th);
310 return pid_to_ptid (-1); /* Thread must have terminated. */
311 else if (val != TD_OK)
312 error (_("thread_to_lwp: td_ta_map_id2thr %s"), td_err_string (val));
314 val = p_td_thr_get_info (&th, &ti);
316 return pid_to_ptid (-1); /* Thread must have terminated. */
317 else if (val != TD_OK)
318 error (_("thread_to_lwp: td_thr_get_info: %s"), td_err_string (val));
320 if (ti.ti_state != TD_THR_ACTIVE)
322 if (default_lwp != -1)
323 return pid_to_ptid (default_lwp);
324 error (_("thread_to_lwp: thread state not active: %s"),
325 td_state_string (ti.ti_state));
328 return ptid_build (ptid_get_pid (thread_id), ti.ti_lid, 0);
331 /* Convert an LWP ID into a POSIX or Solaris thread ID. If LWP_ID
332 doesn't exists, that's an error.
334 NOTE: This function probably shouldn't call error(). */
337 lwp_to_thread (ptid_t lwp)
343 if (ptid_tid_p (lwp))
344 return lwp; /* It's already a thread ID. */
346 /* It's an LWP. Convert it to a thread ID. */
348 if (!target_thread_alive (lwp))
349 return pid_to_ptid (-1); /* Must be a defunct LPW. */
351 val = p_td_ta_map_lwp2thr (main_ta, ptid_get_lwp (lwp), &th);
353 return pid_to_ptid (-1); /* Thread must have terminated. */
354 else if (val != TD_OK)
355 error (_("lwp_to_thread: td_ta_map_lwp2thr: %s."), td_err_string (val));
357 val = p_td_thr_validate (&th);
359 return lwp; /* Unknown to libthread; just return LPW, */
360 else if (val != TD_OK)
361 error (_("lwp_to_thread: td_thr_validate: %s."), td_err_string (val));
363 val = p_td_thr_get_info (&th, &ti);
365 return pid_to_ptid (-1); /* Thread must have terminated. */
366 else if (val != TD_OK)
367 error (_("lwp_to_thread: td_thr_get_info: %s."), td_err_string (val));
369 return ptid_build (ptid_get_pid (lwp), 0 , ti.ti_tid);
373 /* Most target vector functions from here on actually just pass
374 through to the layer beneath, as they don't need to do anything
375 specific for threads. */
377 /* Take a program previously attached to and detaches it. The program
378 resumes execution and will no longer stop on signals, etc. We'd
379 better not have left any breakpoints in the program or it'll die
380 when it hits one. For this to work, it may be necessary for the
381 process to have been previously attached. It *might* work if the
382 program was started via the normal ptrace (PTRACE_TRACEME). */
385 sol_thread_target::detach (inferior *inf, int from_tty)
387 struct target_ops *beneath = find_target_beneath (this);
389 sol_thread_active = 0;
390 inferior_ptid = pid_to_ptid (ptid_get_pid (main_ph.ptid));
391 unpush_target (this);
392 beneath->detach (inf, from_tty);
395 /* Resume execution of process PTID. If STEP is nozero, then just
396 single step it. If SIGNAL is nonzero, restart it with that signal
397 activated. We may have to convert PTID from a thread ID to an LWP
401 sol_thread_target::resume (ptid_t ptid, int step, enum gdb_signal signo)
403 struct target_ops *beneath = find_target_beneath (this);
405 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
407 inferior_ptid = thread_to_lwp (inferior_ptid, ptid_get_pid (main_ph.ptid));
408 if (ptid_get_pid (inferior_ptid) == -1)
409 inferior_ptid = procfs_first_available ();
411 if (ptid_get_pid (ptid) != -1)
413 ptid_t save_ptid = ptid;
415 ptid = thread_to_lwp (ptid, -2);
416 if (ptid_get_pid (ptid) == -2) /* Inactive thread. */
417 error (_("This version of Solaris can't start inactive threads."));
418 if (info_verbose && ptid_get_pid (ptid) == -1)
419 warning (_("Specified thread %ld seems to have terminated"),
420 ptid_get_tid (save_ptid));
423 beneath->resume (ptid, step, signo);
426 /* Wait for any threads to stop. We may have to convert PTID from a
427 thread ID to an LWP ID, and vice versa on the way out. */
430 sol_thread_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
435 struct target_ops *beneath = find_target_beneath (this);
437 save_ptid = inferior_ptid;
438 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
440 inferior_ptid = thread_to_lwp (inferior_ptid, ptid_get_pid (main_ph.ptid));
441 if (ptid_get_pid (inferior_ptid) == -1)
442 inferior_ptid = procfs_first_available ();
444 if (ptid_get_pid (ptid) != -1)
446 ptid_t save_ptid = ptid;
448 ptid = thread_to_lwp (ptid, -2);
449 if (ptid_get_pid (ptid) == -2) /* Inactive thread. */
450 error (_("This version of Solaris can't start inactive threads."));
451 if (info_verbose && ptid_get_pid (ptid) == -1)
452 warning (_("Specified thread %ld seems to have terminated"),
453 ptid_get_tid (save_ptid));
456 rtnval = beneath->wait (ptid, ourstatus, options);
458 if (ourstatus->kind != TARGET_WAITKIND_EXITED)
460 /* Map the LWP of interest back to the appropriate thread ID. */
461 rtnval = lwp_to_thread (rtnval);
462 if (ptid_get_pid (rtnval) == -1)
465 /* See if we have a new thread. */
466 if (ptid_tid_p (rtnval)
467 && !ptid_equal (rtnval, save_ptid)
468 && (!in_thread_list (rtnval)
469 || is_exited (rtnval)))
473 /* During process initialization, we may get here without the thread
474 package being initialized, since that can only happen after we've
475 found the shared libs. */
481 sol_thread_target::fetch_registers (struct regcache *regcache, int regnum)
484 td_thrhandle_t thandle;
487 prfpregset_t fpregset;
488 gdb_gregset_t *gregset_p = &gregset;
489 gdb_fpregset_t *fpregset_p = &fpregset;
490 struct target_ops *beneath = find_target_beneath (this);
491 ptid_t ptid = regcache->ptid ();
493 if (!ptid_tid_p (ptid))
495 /* It's an LWP; pass the request on to the layer beneath. */
496 beneath->fetch_registers (regcache, regnum);
500 /* Solaris thread: convert PTID into a td_thrhandle_t. */
501 thread = ptid_get_tid (ptid);
503 error (_("sol_thread_fetch_registers: thread == 0"));
505 val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
507 error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"),
508 td_err_string (val));
510 /* Get the general-purpose registers. */
512 val = p_td_thr_getgregs (&thandle, gregset);
513 if (val != TD_OK && val != TD_PARTIALREG)
514 error (_("sol_thread_fetch_registers: td_thr_getgregs %s"),
515 td_err_string (val));
517 /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
518 and %sp are saved (by a thread context switch). */
520 /* And, now the floating-point registers. */
522 val = p_td_thr_getfpregs (&thandle, &fpregset);
523 if (val != TD_OK && val != TD_NOFPREGS)
524 error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"),
525 td_err_string (val));
527 /* Note that we must call supply_gregset and supply_fpregset *after*
528 calling the td routines because the td routines call ps_lget*
529 which affect the values stored in the registers array. */
531 supply_gregset (regcache, (const gdb_gregset_t *) gregset_p);
532 supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset_p);
536 sol_thread_target::store_registers (struct regcache *regcache, int regnum)
539 td_thrhandle_t thandle;
542 prfpregset_t fpregset;
543 ptid_t ptid = regcache->ptid ();
545 if (!ptid_tid_p (ptid))
547 struct target_ops *beneath = find_target_beneath (this);
549 /* It's an LWP; pass the request on to the layer beneath. */
550 beneath->store_registers (regcache, regnum);
554 /* Solaris thread: convert PTID into a td_thrhandle_t. */
555 thread = ptid_get_tid (ptid);
557 val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
559 error (_("sol_thread_store_registers: td_ta_map_id2thr %s"),
560 td_err_string (val));
564 val = p_td_thr_getgregs (&thandle, gregset);
566 error (_("sol_thread_store_registers: td_thr_getgregs %s"),
567 td_err_string (val));
568 val = p_td_thr_getfpregs (&thandle, &fpregset);
570 error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
571 td_err_string (val));
574 fill_gregset (regcache, (gdb_gregset_t *) &gregset, regnum);
575 fill_fpregset (regcache, (gdb_fpregset_t *) &fpregset, regnum);
577 val = p_td_thr_setgregs (&thandle, gregset);
579 error (_("sol_thread_store_registers: td_thr_setgregs %s"),
580 td_err_string (val));
581 val = p_td_thr_setfpregs (&thandle, &fpregset);
583 error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
584 td_err_string (val));
587 /* Perform partial transfers on OBJECT. See target_read_partial and
588 target_write_partial for details of each variant. One, and only
589 one, of readbuf or writebuf must be non-NULL. */
591 enum target_xfer_status
592 sol_thread_target::xfer_partial (enum target_object object,
593 const char *annex, gdb_byte *readbuf,
594 const gdb_byte *writebuf,
595 ULONGEST offset, ULONGEST len,
596 ULONGEST *xfered_len)
598 struct target_ops *beneath = find_target_beneath (this);
600 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
602 if (ptid_tid_p (inferior_ptid) || !target_thread_alive (inferior_ptid))
604 /* It's either a thread or an LWP that isn't alive. Any live
605 LWP will do so use the first available.
607 NOTE: We don't need to call switch_to_thread; we're just
609 inferior_ptid = procfs_first_available ();
612 return beneath->xfer_partial (object, annex, readbuf,
613 writebuf, offset, len, xfered_len);
617 check_for_thread_db (void)
622 /* Don't attempt to use thread_db for remote targets. */
623 if (!(target_can_run () || core_bfd))
626 /* Do nothing if we couldn't load libthread_db.so.1. */
627 if (p_td_ta_new == NULL)
630 if (sol_thread_active)
631 /* Nothing to do. The thread library was already detected and the
632 target vector was already activated. */
635 /* Now, initialize libthread_db. This needs to be done after the
636 shared libraries are located because it needs information from
637 the user's thread library. */
642 warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (err));
646 /* Now attempt to open a connection to the thread library. */
647 err = p_td_ta_new (&main_ph, &main_ta);
651 /* No thread library was detected. */
655 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
657 /* The thread library was detected. Activate the sol_thread target. */
658 push_target (&sol_thread_ops);
659 sol_thread_active = 1;
661 main_ph.ptid = inferior_ptid; /* Save for xfer_memory. */
662 ptid = lwp_to_thread (inferior_ptid);
663 if (ptid_get_pid (ptid) != -1)
664 inferior_ptid = ptid;
666 target_update_thread_list ();
670 warning (_("Cannot initialize thread debugging library: %s"),
671 td_err_string (err));
676 /* This routine is called whenever a new symbol table is read in, or
677 when all symbol tables are removed. libthread_db can only be
678 initialized when it finds the right variables in libthread.so.
679 Since it's a shared library, those variables don't show up until
680 the library gets mapped and the symbol table is read in. */
683 sol_thread_new_objfile (struct objfile *objfile)
686 check_for_thread_db ();
689 /* Clean up after the inferior dies. */
692 sol_thread_target::mourn_inferior ()
694 struct target_ops *beneath = find_target_beneath (this);
696 sol_thread_active = 0;
698 unpush_target (this);
700 beneath->mourn_inferior ();
703 /* Return true if PTID is still active in the inferior. */
706 sol_thread_target::thread_alive (ptid_t ptid)
708 if (ptid_tid_p (ptid))
710 /* It's a (user-level) thread. */
715 pid = ptid_get_tid (ptid);
716 if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK)
717 return false; /* Thread not found. */
718 if ((val = p_td_thr_validate (&th)) != TD_OK)
719 return false; /* Thread not valid. */
720 return true; /* Known thread. */
724 struct target_ops *beneath = find_target_beneath (this);
726 /* It's an LPW; pass the request on to the layer below. */
727 return beneath->thread_alive (ptid);
732 /* These routines implement the lower half of the thread_db interface,
733 i.e. the ps_* routines. */
735 /* The next four routines are called by libthread_db to tell us to
736 stop and stop a particular process or lwp. Since GDB ensures that
737 these are all stopped by the time we call anything in thread_db,
738 these routines need to do nothing. */
743 ps_pstop (struct ps_prochandle *ph)
748 /* Process continue. */
751 ps_pcontinue (struct ps_prochandle *ph)
759 ps_lstop (struct ps_prochandle *ph, lwpid_t lwpid)
767 ps_lcontinue (struct ps_prochandle *ph, lwpid_t lwpid)
772 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
775 ps_pglobal_lookup (struct ps_prochandle *ph, const char *ld_object_name,
776 const char *ld_symbol_name, psaddr_t *ld_symbol_addr)
778 struct bound_minimal_symbol ms;
780 ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL);
784 *ld_symbol_addr = BMSYMBOL_VALUE_ADDRESS (ms);
788 /* Common routine for reading and writing memory. */
791 rw_common (int dowrite, const struct ps_prochandle *ph, psaddr_t addr,
792 gdb_byte *buf, int size)
796 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
798 if (ptid_tid_p (inferior_ptid) || !target_thread_alive (inferior_ptid))
800 /* It's either a thread or an LWP that isn't alive. Any live
801 LWP will do so use the first available.
803 NOTE: We don't need to call switch_to_thread; we're just
805 inferior_ptid = procfs_first_available ();
808 #if defined (__sparcv9)
809 /* For Sparc64 cross Sparc32, make sure the address has not been
810 accidentally sign-extended (or whatever) to beyond 32 bits. */
811 if (bfd_get_arch_size (exec_bfd) == 32)
816 ret = target_write_memory (addr, (gdb_byte *) buf, size);
818 ret = target_read_memory (addr, (gdb_byte *) buf, size);
820 return (ret == 0 ? PS_OK : PS_ERR);
823 /* Copies SIZE bytes from target process .data segment to debugger memory. */
826 ps_pdread (struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t size)
828 return rw_common (0, ph, addr, (gdb_byte *) buf, size);
831 /* Copies SIZE bytes from debugger memory .data segment to target process. */
834 ps_pdwrite (struct ps_prochandle *ph, psaddr_t addr,
835 const void *buf, size_t size)
837 return rw_common (1, ph, addr, (gdb_byte *) buf, size);
840 /* Copies SIZE bytes from target process .text segment to debugger memory. */
843 ps_ptread (struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t size)
845 return rw_common (0, ph, addr, (gdb_byte *) buf, size);
848 /* Copies SIZE bytes from debugger memory .text segment to target process. */
851 ps_ptwrite (struct ps_prochandle *ph, psaddr_t addr,
852 const void *buf, size_t size)
854 return rw_common (1, ph, addr, (gdb_byte *) buf, size);
857 /* Get general-purpose registers for LWP. */
860 ps_lgetregs (struct ps_prochandle *ph, lwpid_t lwpid, prgregset_t gregset)
862 ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
863 struct regcache *regcache
864 = get_thread_arch_regcache (ptid, target_gdbarch ());
866 target_fetch_registers (regcache, -1);
867 fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
872 /* Set general-purpose registers for LWP. */
875 ps_lsetregs (struct ps_prochandle *ph, lwpid_t lwpid,
876 const prgregset_t gregset)
878 ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
879 struct regcache *regcache
880 = get_thread_arch_regcache (ptid, target_gdbarch ());
882 supply_gregset (regcache, (const gdb_gregset_t *) gregset);
883 target_store_registers (regcache, -1);
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 (struct ps_prochandle *ph, lwpid_t lwpid, int *xregsize)
908 /* Get extra register set. Currently a noop. */
911 ps_lgetxregs (struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
916 /* Set extra register set. Currently a noop. */
919 ps_lsetxregs (struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
924 /* Get floating-point registers for LWP. */
927 ps_lgetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
928 prfpregset_t *fpregset)
930 ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
931 struct regcache *regcache
932 = get_thread_arch_regcache (ptid, target_gdbarch ());
934 target_fetch_registers (regcache, -1);
935 fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
940 /* Set floating-point regs for LWP. */
943 ps_lsetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
944 const prfpregset_t * fpregset)
946 ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
947 struct regcache *regcache
948 = get_thread_arch_regcache (ptid, target_gdbarch ());
950 supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
951 target_store_registers (regcache, -1);
957 /* Identify process as 32-bit or 64-bit. At the moment we're using
958 BFD to do this. There might be a more Solaris-specific
959 (e.g. procfs) method, but this ought to work. */
962 ps_pdmodel (struct ps_prochandle *ph, int *data_model)
965 *data_model = PR_MODEL_UNKNOWN;
966 else if (bfd_get_arch_size (exec_bfd) == 32)
967 *data_model = PR_MODEL_ILP32;
969 *data_model = PR_MODEL_LP64;
973 #endif /* PR_MODEL_LP64 */
975 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
977 /* Reads the local descriptor table of a LWP.
979 This function is necessary on x86-solaris only. Without it, the loading
980 of libthread_db would fail because of ps_lgetLDT being undefined. */
983 ps_lgetLDT (struct ps_prochandle *ph, lwpid_t lwpid,
986 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */
989 /* FIXME: can't I get the process ID from the prochandle or
992 if (ptid_get_pid (inferior_ptid) <= 0 || lwpid <= 0)
995 ret = procfs_find_LDT_entry (ptid_build (ptid_get_pid (inferior_ptid),
999 memcpy (pldt, ret, sizeof (struct ssd));
1003 /* LDT not found. */
1009 /* Convert PTID to printable form. */
1012 sol_thread_target::pid_to_str (ptid_t ptid)
1014 static char buf[100];
1016 if (ptid_tid_p (ptid))
1020 lwp = thread_to_lwp (ptid, -2);
1022 if (ptid_get_pid (lwp) == -1)
1023 xsnprintf (buf, sizeof (buf), "Thread %ld (defunct)",
1024 ptid_get_tid (ptid));
1025 else if (ptid_get_pid (lwp) != -2)
1026 xsnprintf (buf, sizeof (buf), "Thread %ld (LWP %ld)",
1027 ptid_get_tid (ptid), ptid_get_lwp (lwp));
1029 xsnprintf (buf, sizeof (buf), "Thread %ld ",
1030 ptid_get_tid (ptid));
1032 else if (ptid_get_lwp (ptid) != 0)
1033 xsnprintf (buf, sizeof (buf), "LWP %ld ", ptid_get_lwp (ptid));
1035 xsnprintf (buf, sizeof (buf), "process %d ", ptid_get_pid (ptid));
1041 /* Worker bee for update_thread_list. Callback function that gets
1042 called once per user-level thread (i.e. not for LWP's). */
1045 sol_update_thread_list_callback (const td_thrhandle_t *th, void *ignored)
1051 retval = p_td_thr_get_info (th, &ti);
1052 if (retval != TD_OK)
1055 ptid = ptid_build (ptid_get_pid (inferior_ptid), 0, ti.ti_tid);
1056 if (!in_thread_list (ptid) || is_exited (ptid))
1063 sol_thread_target::update_thread_list ()
1065 struct target_ops *beneath = find_target_beneath (this);
1067 /* Delete dead threads. */
1070 /* Find any new LWP's. */
1071 beneath->update_thread_list ();
1073 /* Then find any new user-level threads. */
1074 p_td_ta_thr_iter (main_ta, sol_update_thread_list_callback, (void *) 0,
1075 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1076 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1079 /* Worker bee for the "info sol-thread" command. This is a callback
1080 function that gets called once for each Solaris user-level thread
1081 (i.e. not for LWPs) in the inferior. Print anything interesting
1082 that we can think of. */
1085 info_cb (const td_thrhandle_t *th, void *s)
1090 ret = p_td_thr_get_info (th, &ti);
1093 printf_filtered ("%s thread #%d, lwp %d, ",
1094 ti.ti_type == TD_THR_SYSTEM ? "system" : "user ",
1095 ti.ti_tid, ti.ti_lid);
1096 switch (ti.ti_state)
1099 case TD_THR_UNKNOWN:
1100 printf_filtered ("<unknown state>");
1102 case TD_THR_STOPPED:
1103 printf_filtered ("(stopped)");
1106 printf_filtered ("(run) ");
1109 printf_filtered ("(active) ");
1112 printf_filtered ("(zombie) ");
1115 printf_filtered ("(asleep) ");
1117 case TD_THR_STOPPED_ASLEEP:
1118 printf_filtered ("(stopped asleep)");
1121 /* Print thr_create start function. */
1122 if (ti.ti_startfunc != 0)
1124 const struct bound_minimal_symbol msym
1125 = lookup_minimal_symbol_by_pc (ti.ti_startfunc);
1127 printf_filtered (" startfunc=%s",
1129 ? MSYMBOL_PRINT_NAME (msym.minsym)
1130 : paddress (target_gdbarch (), ti.ti_startfunc));
1133 /* If thread is asleep, print function that went to sleep. */
1134 if (ti.ti_state == TD_THR_SLEEP)
1136 const struct bound_minimal_symbol msym
1137 = lookup_minimal_symbol_by_pc (ti.ti_pc);
1139 printf_filtered (" sleepfunc=%s",
1141 ? MSYMBOL_PRINT_NAME (msym.minsym)
1142 : paddress (target_gdbarch (), ti.ti_pc));
1145 printf_filtered ("\n");
1148 warning (_("info sol-thread: failed to get info for thread."));
1153 /* List some state about each Solaris user-level thread in the
1157 info_solthreads (const char *args, int from_tty)
1159 p_td_ta_thr_iter (main_ta, info_cb, (void *) args,
1160 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1161 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1164 /* Callback routine used to find a thread based on the TID part of
1168 thread_db_find_thread_from_tid (struct thread_info *thread, void *data)
1170 long *tid = (long *) data;
1172 if (ptid_get_tid (thread->ptid) == *tid)
1179 sol_thread_target::get_ada_task_ptid (long lwp, long thread)
1181 struct thread_info *thread_info =
1182 iterate_over_threads (thread_db_find_thread_from_tid, &thread);
1184 if (thread_info == NULL)
1186 /* The list of threads is probably not up to date. Find any
1187 thread that is missing from the list, and try again. */
1188 update_thread_list ();
1189 thread_info = iterate_over_threads (thread_db_find_thread_from_tid,
1193 gdb_assert (thread_info != NULL);
1195 return (thread_info->ptid);
1199 _initialize_sol_thread (void)
1203 dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW);
1207 #define resolve(X) \
1208 if (!(p_##X = (X ## _ftype *) dlsym (dlhandle, #X))) \
1212 resolve (td_ta_new);
1213 resolve (td_ta_delete);
1215 resolve (td_ta_get_ph);
1216 resolve (td_ta_get_nthreads);
1217 resolve (td_ta_tsd_iter);
1218 resolve (td_ta_thr_iter);
1219 resolve (td_thr_validate);
1220 resolve (td_thr_tsd);
1221 resolve (td_thr_get_info);
1222 resolve (td_thr_getfpregs);
1223 resolve (td_thr_getxregsize);
1224 resolve (td_thr_getxregs);
1225 resolve (td_thr_sigsetmask);
1226 resolve (td_thr_setprio);
1227 resolve (td_thr_setsigpending);
1228 resolve (td_thr_setfpregs);
1229 resolve (td_thr_setxregs);
1230 resolve (td_ta_map_id2thr);
1231 resolve (td_ta_map_lwp2thr);
1232 resolve (td_thr_getgregs);
1233 resolve (td_thr_setgregs);
1235 add_cmd ("sol-threads", class_maintenance, info_solthreads,
1236 _("Show info on Solaris user threads."), &maintenanceinfolist);
1238 /* Hook into new_objfile notification. */
1239 gdb::observers::new_objfile.attach (sol_thread_new_objfile);
1243 fprintf_unfiltered (gdb_stderr, "\
1244 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ());