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 class sol_thread_target final : public target_ops
76 { this->to_stratum = thread_stratum; }
78 const char *shortname () override
79 { return "solaris-threads"; }
80 const char *longname () override
81 { return _("Solaris threads and pthread."); }
82 const char *doc () override
83 { return _("Solaris threads and pthread support."); }
85 void detach (inferior *, int) override;
86 ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
87 void resume (ptid_t, int, enum gdb_signal) override;
88 void mourn_inferior () override;
89 const char *pid_to_str (ptid_t) override;
90 ptid_t get_ada_task_ptid (long lwp, long thread) override;
92 void fetch_registers (struct regcache *, int) override;
93 void store_registers (struct regcache *, int) override;
95 enum target_xfer_status xfer_partial (enum target_object object,
98 const gdb_byte *writebuf,
99 ULONGEST offset, ULONGEST len,
100 ULONGEST *xfered_len) override;
102 int thread_alive (ptid_t ptid) override;
103 void update_thread_list () override;
106 static sol_thread_target sol_thread_ops;
108 /* Prototypes for supply_gregset etc. */
111 /* This struct is defined by us, but mainly used for the proc_service
112 interface. We don't have much use for it, except as a handy place
113 to get a real PID for memory accesses. */
126 static struct ps_prochandle main_ph;
127 static td_thragent_t *main_ta;
128 static int sol_thread_active = 0;
130 /* Default definitions: These must be defined in tm.h if they are to
131 be shared with a process module such as procfs. */
133 /* Types of the libthread_db functions. */
135 typedef void (td_log_ftype)(const int on_off);
136 typedef td_err_e (td_ta_new_ftype)(const struct ps_prochandle *ph_p,
137 td_thragent_t **ta_pp);
138 typedef td_err_e (td_ta_delete_ftype)(td_thragent_t *ta_p);
139 typedef td_err_e (td_init_ftype)(void);
140 typedef td_err_e (td_ta_get_ph_ftype)(const td_thragent_t *ta_p,
141 struct ps_prochandle **ph_pp);
142 typedef td_err_e (td_ta_get_nthreads_ftype)(const td_thragent_t *ta_p,
144 typedef td_err_e (td_ta_tsd_iter_ftype)(const td_thragent_t *ta_p,
145 td_key_iter_f *cb, void *cbdata_p);
146 typedef td_err_e (td_ta_thr_iter_ftype)(const td_thragent_t *ta_p,
147 td_thr_iter_f *cb, void *cbdata_p,
148 td_thr_state_e state, int ti_pri,
149 sigset_t *ti_sigmask_p,
150 unsigned ti_user_flags);
151 typedef td_err_e (td_thr_validate_ftype)(const td_thrhandle_t *th_p);
152 typedef td_err_e (td_thr_tsd_ftype)(const td_thrhandle_t * th_p,
153 const thread_key_t key, void **data_pp);
154 typedef td_err_e (td_thr_get_info_ftype)(const td_thrhandle_t *th_p,
156 typedef td_err_e (td_thr_getfpregs_ftype)(const td_thrhandle_t *th_p,
157 prfpregset_t *fpregset);
158 typedef td_err_e (td_thr_getxregsize_ftype)(const td_thrhandle_t *th_p,
160 typedef td_err_e (td_thr_getxregs_ftype)(const td_thrhandle_t *th_p,
161 const caddr_t xregset);
162 typedef td_err_e (td_thr_sigsetmask_ftype)(const td_thrhandle_t *th_p,
163 const sigset_t ti_sigmask);
164 typedef td_err_e (td_thr_setprio_ftype)(const td_thrhandle_t *th_p,
166 typedef td_err_e (td_thr_setsigpending_ftype)(const td_thrhandle_t *th_p,
167 const uchar_t ti_pending_flag,
168 const sigset_t ti_pending);
169 typedef td_err_e (td_thr_setfpregs_ftype)(const td_thrhandle_t *th_p,
170 const prfpregset_t *fpregset);
171 typedef td_err_e (td_thr_setxregs_ftype)(const td_thrhandle_t *th_p,
172 const caddr_t xregset);
173 typedef td_err_e (td_ta_map_id2thr_ftype)(const td_thragent_t *ta_p,
175 td_thrhandle_t *th_p);
176 typedef td_err_e (td_ta_map_lwp2thr_ftype)(const td_thragent_t *ta_p,
178 td_thrhandle_t *th_p);
179 typedef td_err_e (td_thr_getgregs_ftype)(const td_thrhandle_t *th_p,
181 typedef td_err_e (td_thr_setgregs_ftype)(const td_thrhandle_t *th_p,
182 const prgregset_t regset);
184 /* Pointers to routines from libthread_db resolved by dlopen(). */
186 static td_log_ftype *p_td_log;
187 static td_ta_new_ftype *p_td_ta_new;
188 static td_ta_delete_ftype *p_td_ta_delete;
189 static td_init_ftype *p_td_init;
190 static td_ta_get_ph_ftype *p_td_ta_get_ph;
191 static td_ta_get_nthreads_ftype *p_td_ta_get_nthreads;
192 static td_ta_tsd_iter_ftype *p_td_ta_tsd_iter;
193 static td_ta_thr_iter_ftype *p_td_ta_thr_iter;
194 static td_thr_validate_ftype *p_td_thr_validate;
195 static td_thr_tsd_ftype *p_td_thr_tsd;
196 static td_thr_get_info_ftype *p_td_thr_get_info;
197 static td_thr_getfpregs_ftype *p_td_thr_getfpregs;
198 static td_thr_getxregsize_ftype *p_td_thr_getxregsize;
199 static td_thr_getxregs_ftype *p_td_thr_getxregs;
200 static td_thr_sigsetmask_ftype *p_td_thr_sigsetmask;
201 static td_thr_setprio_ftype *p_td_thr_setprio;
202 static td_thr_setsigpending_ftype *p_td_thr_setsigpending;
203 static td_thr_setfpregs_ftype *p_td_thr_setfpregs;
204 static td_thr_setxregs_ftype *p_td_thr_setxregs;
205 static td_ta_map_id2thr_ftype *p_td_ta_map_id2thr;
206 static td_ta_map_lwp2thr_ftype *p_td_ta_map_lwp2thr;
207 static td_thr_getgregs_ftype *p_td_thr_getgregs;
208 static td_thr_setgregs_ftype *p_td_thr_setgregs;
211 /* Return the libthread_db error string associated with ERRCODE. If
212 ERRCODE is unknown, return an appropriate message. */
215 td_err_string (td_err_e errcode)
217 static struct string_map td_err_table[] =
219 { TD_OK, "generic \"call succeeded\"" },
220 { TD_ERR, "generic error." },
221 { TD_NOTHR, "no thread can be found to satisfy query" },
222 { TD_NOSV, "no synch. variable can be found to satisfy query" },
223 { TD_NOLWP, "no lwp can be found to satisfy query" },
224 { TD_BADPH, "invalid process handle" },
225 { TD_BADTH, "invalid thread handle" },
226 { TD_BADSH, "invalid synchronization handle" },
227 { TD_BADTA, "invalid thread agent" },
228 { TD_BADKEY, "invalid key" },
229 { TD_NOMSG, "td_thr_event_getmsg() called when there was no message" },
230 { TD_NOFPREGS, "FPU register set not available for given thread" },
231 { TD_NOLIBTHREAD, "application not linked with libthread" },
232 { TD_NOEVENT, "requested event is not supported" },
233 { TD_NOCAPAB, "capability not available" },
234 { TD_DBERR, "Debugger service failed" },
235 { TD_NOAPLIC, "Operation not applicable to" },
236 { TD_NOTSD, "No thread specific data for this thread" },
237 { TD_MALLOC, "Malloc failed" },
238 { TD_PARTIALREG, "Only part of register set was written/read" },
239 { TD_NOXREGS, "X register set not available for given thread" }
241 const int td_err_size = sizeof td_err_table / sizeof (struct string_map);
245 for (i = 0; i < td_err_size; i++)
246 if (td_err_table[i].num == errcode)
247 return td_err_table[i].str;
249 xsnprintf (buf, sizeof (buf), "Unknown libthread_db error code: %d",
255 /* Return the libthread_db state string assicoated with STATECODE.
256 If STATECODE is unknown, return an appropriate message. */
259 td_state_string (td_thr_state_e statecode)
261 static struct string_map td_thr_state_table[] =
263 { TD_THR_ANY_STATE, "any state" },
264 { TD_THR_UNKNOWN, "unknown" },
265 { TD_THR_STOPPED, "stopped" },
266 { TD_THR_RUN, "run" },
267 { TD_THR_ACTIVE, "active" },
268 { TD_THR_ZOMBIE, "zombie" },
269 { TD_THR_SLEEP, "sleep" },
270 { TD_THR_STOPPED_ASLEEP, "stopped asleep" }
272 const int td_thr_state_table_size =
273 sizeof td_thr_state_table / sizeof (struct string_map);
277 for (i = 0; i < td_thr_state_table_size; i++)
278 if (td_thr_state_table[i].num == statecode)
279 return td_thr_state_table[i].str;
281 xsnprintf (buf, sizeof (buf), "Unknown libthread_db state code: %d",
288 /* Convert a POSIX or Solaris thread ID into a LWP ID. If THREAD_ID
289 doesn't exist, that's an error. If it's an inactive thread, return
292 NOTE: This function probably shouldn't call error(). */
295 thread_to_lwp (ptid_t thread_id, int default_lwp)
301 if (ptid_lwp_p (thread_id))
302 return thread_id; /* It's already an LWP ID. */
304 /* It's a thread. Convert to LWP. */
306 val = p_td_ta_map_id2thr (main_ta, ptid_get_tid (thread_id), &th);
308 return pid_to_ptid (-1); /* Thread must have terminated. */
309 else if (val != TD_OK)
310 error (_("thread_to_lwp: td_ta_map_id2thr %s"), td_err_string (val));
312 val = p_td_thr_get_info (&th, &ti);
314 return pid_to_ptid (-1); /* Thread must have terminated. */
315 else if (val != TD_OK)
316 error (_("thread_to_lwp: td_thr_get_info: %s"), td_err_string (val));
318 if (ti.ti_state != TD_THR_ACTIVE)
320 if (default_lwp != -1)
321 return pid_to_ptid (default_lwp);
322 error (_("thread_to_lwp: thread state not active: %s"),
323 td_state_string (ti.ti_state));
326 return ptid_build (ptid_get_pid (thread_id), ti.ti_lid, 0);
329 /* Convert an LWP ID into a POSIX or Solaris thread ID. If LWP_ID
330 doesn't exists, that's an error.
332 NOTE: This function probably shouldn't call error(). */
335 lwp_to_thread (ptid_t lwp)
341 if (ptid_tid_p (lwp))
342 return lwp; /* It's already a thread ID. */
344 /* It's an LWP. Convert it to a thread ID. */
346 if (!target_thread_alive (lwp))
347 return pid_to_ptid (-1); /* Must be a defunct LPW. */
349 val = p_td_ta_map_lwp2thr (main_ta, ptid_get_lwp (lwp), &th);
351 return pid_to_ptid (-1); /* Thread must have terminated. */
352 else if (val != TD_OK)
353 error (_("lwp_to_thread: td_ta_map_lwp2thr: %s."), td_err_string (val));
355 val = p_td_thr_validate (&th);
357 return lwp; /* Unknown to libthread; just return LPW, */
358 else if (val != TD_OK)
359 error (_("lwp_to_thread: td_thr_validate: %s."), td_err_string (val));
361 val = p_td_thr_get_info (&th, &ti);
363 return pid_to_ptid (-1); /* Thread must have terminated. */
364 else if (val != TD_OK)
365 error (_("lwp_to_thread: td_thr_get_info: %s."), td_err_string (val));
367 return ptid_build (ptid_get_pid (lwp), 0 , ti.ti_tid);
371 /* Most target vector functions from here on actually just pass
372 through to the layer beneath, as they don't need to do anything
373 specific for threads. */
375 /* Take a program previously attached to and detaches it. The program
376 resumes execution and will no longer stop on signals, etc. We'd
377 better not have left any breakpoints in the program or it'll die
378 when it hits one. For this to work, it may be necessary for the
379 process to have been previously attached. It *might* work if the
380 program was started via the normal ptrace (PTRACE_TRACEME). */
383 sol_thread_target::detach (inferior *inf, int from_tty)
385 struct target_ops *beneath = find_target_beneath (this);
387 sol_thread_active = 0;
388 inferior_ptid = pid_to_ptid (ptid_get_pid (main_ph.ptid));
389 unpush_target (this);
390 beneath->detach (inf, from_tty);
393 /* Resume execution of process PTID. If STEP is nozero, then just
394 single step it. If SIGNAL is nonzero, restart it with that signal
395 activated. We may have to convert PTID from a thread ID to an LWP
399 sol_thread_target::resume (ptid_t ptid, int step, enum gdb_signal signo)
401 struct target_ops *beneath = find_target_beneath (this);
403 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
405 inferior_ptid = thread_to_lwp (inferior_ptid, ptid_get_pid (main_ph.ptid));
406 if (ptid_get_pid (inferior_ptid) == -1)
407 inferior_ptid = procfs_first_available ();
409 if (ptid_get_pid (ptid) != -1)
411 ptid_t save_ptid = ptid;
413 ptid = thread_to_lwp (ptid, -2);
414 if (ptid_get_pid (ptid) == -2) /* Inactive thread. */
415 error (_("This version of Solaris can't start inactive threads."));
416 if (info_verbose && ptid_get_pid (ptid) == -1)
417 warning (_("Specified thread %ld seems to have terminated"),
418 ptid_get_tid (save_ptid));
421 beneath->resume (ptid, step, signo);
424 /* Wait for any threads to stop. We may have to convert PTID from a
425 thread ID to an LWP ID, and vice versa on the way out. */
428 sol_thread_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
433 struct target_ops *beneath = find_target_beneath (this);
435 save_ptid = inferior_ptid;
436 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
438 inferior_ptid = thread_to_lwp (inferior_ptid, ptid_get_pid (main_ph.ptid));
439 if (ptid_get_pid (inferior_ptid) == -1)
440 inferior_ptid = procfs_first_available ();
442 if (ptid_get_pid (ptid) != -1)
444 ptid_t save_ptid = ptid;
446 ptid = thread_to_lwp (ptid, -2);
447 if (ptid_get_pid (ptid) == -2) /* Inactive thread. */
448 error (_("This version of Solaris can't start inactive threads."));
449 if (info_verbose && ptid_get_pid (ptid) == -1)
450 warning (_("Specified thread %ld seems to have terminated"),
451 ptid_get_tid (save_ptid));
454 rtnval = beneath->wait (ptid, ourstatus, options);
456 if (ourstatus->kind != TARGET_WAITKIND_EXITED)
458 /* Map the LWP of interest back to the appropriate thread ID. */
459 rtnval = lwp_to_thread (rtnval);
460 if (ptid_get_pid (rtnval) == -1)
463 /* See if we have a new thread. */
464 if (ptid_tid_p (rtnval)
465 && !ptid_equal (rtnval, save_ptid)
466 && (!in_thread_list (rtnval)
467 || is_exited (rtnval)))
471 /* During process initialization, we may get here without the thread
472 package being initialized, since that can only happen after we've
473 found the shared libs. */
479 sol_thread_target::fetch_registers (struct regcache *regcache, int regnum)
482 td_thrhandle_t thandle;
485 prfpregset_t fpregset;
486 gdb_gregset_t *gregset_p = &gregset;
487 gdb_fpregset_t *fpregset_p = &fpregset;
488 struct target_ops *beneath = find_target_beneath (this);
489 ptid_t ptid = regcache_get_ptid (regcache);
491 if (!ptid_tid_p (ptid))
493 /* It's an LWP; pass the request on to the layer beneath. */
494 beneath->fetch_registers (regcache, regnum);
498 /* Solaris thread: convert PTID into a td_thrhandle_t. */
499 thread = ptid_get_tid (ptid);
501 error (_("sol_thread_fetch_registers: thread == 0"));
503 val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
505 error (_("sol_thread_fetch_registers: td_ta_map_id2thr: %s"),
506 td_err_string (val));
508 /* Get the general-purpose registers. */
510 val = p_td_thr_getgregs (&thandle, gregset);
511 if (val != TD_OK && val != TD_PARTIALREG)
512 error (_("sol_thread_fetch_registers: td_thr_getgregs %s"),
513 td_err_string (val));
515 /* For SPARC, TD_PARTIALREG means that only %i0...%i7, %l0..%l7, %pc
516 and %sp are saved (by a thread context switch). */
518 /* And, now the floating-point registers. */
520 val = p_td_thr_getfpregs (&thandle, &fpregset);
521 if (val != TD_OK && val != TD_NOFPREGS)
522 error (_("sol_thread_fetch_registers: td_thr_getfpregs %s"),
523 td_err_string (val));
525 /* Note that we must call supply_gregset and supply_fpregset *after*
526 calling the td routines because the td routines call ps_lget*
527 which affect the values stored in the registers array. */
529 supply_gregset (regcache, (const gdb_gregset_t *) gregset_p);
530 supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset_p);
534 sol_thread_target::store_registers (struct regcache *regcache, int regnum)
537 td_thrhandle_t thandle;
540 prfpregset_t fpregset;
541 ptid_t ptid = regcache_get_ptid (regcache);
543 if (!ptid_tid_p (ptid))
545 struct target_ops *beneath = find_target_beneath (this);
547 /* It's an LWP; pass the request on to the layer beneath. */
548 beneath->store_registers (regcache, regnum);
552 /* Solaris thread: convert PTID into a td_thrhandle_t. */
553 thread = ptid_get_tid (ptid);
555 val = p_td_ta_map_id2thr (main_ta, thread, &thandle);
557 error (_("sol_thread_store_registers: td_ta_map_id2thr %s"),
558 td_err_string (val));
562 val = p_td_thr_getgregs (&thandle, gregset);
564 error (_("sol_thread_store_registers: td_thr_getgregs %s"),
565 td_err_string (val));
566 val = p_td_thr_getfpregs (&thandle, &fpregset);
568 error (_("sol_thread_store_registers: td_thr_getfpregs %s"),
569 td_err_string (val));
572 fill_gregset (regcache, (gdb_gregset_t *) &gregset, regnum);
573 fill_fpregset (regcache, (gdb_fpregset_t *) &fpregset, regnum);
575 val = p_td_thr_setgregs (&thandle, gregset);
577 error (_("sol_thread_store_registers: td_thr_setgregs %s"),
578 td_err_string (val));
579 val = p_td_thr_setfpregs (&thandle, &fpregset);
581 error (_("sol_thread_store_registers: td_thr_setfpregs %s"),
582 td_err_string (val));
585 /* Perform partial transfers on OBJECT. See target_read_partial and
586 target_write_partial for details of each variant. One, and only
587 one, of readbuf or writebuf must be non-NULL. */
589 enum target_xfer_status
590 sol_thread_target::xfer_partial (enum target_object object,
591 const char *annex, gdb_byte *readbuf,
592 const gdb_byte *writebuf,
593 ULONGEST offset, ULONGEST len,
594 ULONGEST *xfered_len)
596 struct target_ops *beneath = find_target_beneath (this);
598 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
600 if (ptid_tid_p (inferior_ptid) || !target_thread_alive (inferior_ptid))
602 /* It's either a thread or an LWP that isn't alive. Any live
603 LWP will do so use the first available.
605 NOTE: We don't need to call switch_to_thread; we're just
607 inferior_ptid = procfs_first_available ();
610 return beneath->xfer_partial (object, annex, readbuf,
611 writebuf, offset, len, xfered_len);
615 check_for_thread_db (void)
620 /* Don't attempt to use thread_db for remote targets. */
621 if (!(target_can_run () || core_bfd))
624 /* Do nothing if we couldn't load libthread_db.so.1. */
625 if (p_td_ta_new == NULL)
628 if (sol_thread_active)
629 /* Nothing to do. The thread library was already detected and the
630 target vector was already activated. */
633 /* Now, initialize libthread_db. This needs to be done after the
634 shared libraries are located because it needs information from
635 the user's thread library. */
640 warning (_("sol_thread_new_objfile: td_init: %s"), td_err_string (err));
644 /* Now attempt to open a connection to the thread library. */
645 err = p_td_ta_new (&main_ph, &main_ta);
649 /* No thread library was detected. */
653 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
655 /* The thread library was detected. Activate the sol_thread target. */
656 push_target (&sol_thread_ops);
657 sol_thread_active = 1;
659 main_ph.ptid = inferior_ptid; /* Save for xfer_memory. */
660 ptid = lwp_to_thread (inferior_ptid);
661 if (ptid_get_pid (ptid) != -1)
662 inferior_ptid = ptid;
664 target_update_thread_list ();
668 warning (_("Cannot initialize thread debugging library: %s"),
669 td_err_string (err));
674 /* This routine is called whenever a new symbol table is read in, or
675 when all symbol tables are removed. libthread_db can only be
676 initialized when it finds the right variables in libthread.so.
677 Since it's a shared library, those variables don't show up until
678 the library gets mapped and the symbol table is read in. */
681 sol_thread_new_objfile (struct objfile *objfile)
684 check_for_thread_db ();
687 /* Clean up after the inferior dies. */
690 sol_thread_target::mourn_inferior ()
692 struct target_ops *beneath = find_target_beneath (this);
694 sol_thread_active = 0;
696 unpush_target (this);
698 beneath->mourn_inferior ();
701 /* Return true if PTID is still active in the inferior. */
704 sol_thread_target::thread_alive (ptid_t ptid)
706 if (ptid_tid_p (ptid))
708 /* It's a (user-level) thread. */
713 pid = ptid_get_tid (ptid);
714 if ((val = p_td_ta_map_id2thr (main_ta, pid, &th)) != TD_OK)
715 return 0; /* Thread not found. */
716 if ((val = p_td_thr_validate (&th)) != TD_OK)
717 return 0; /* Thread not valid. */
718 return 1; /* Known thread. */
722 struct target_ops *beneath = find_target_beneath (this);
724 /* It's an LPW; pass the request on to the layer below. */
725 return beneath->thread_alive (ptid);
730 /* These routines implement the lower half of the thread_db interface,
731 i.e. the ps_* routines. */
733 /* The next four routines are called by libthread_db to tell us to
734 stop and stop a particular process or lwp. Since GDB ensures that
735 these are all stopped by the time we call anything in thread_db,
736 these routines need to do nothing. */
741 ps_pstop (struct ps_prochandle *ph)
746 /* Process continue. */
749 ps_pcontinue (struct ps_prochandle *ph)
757 ps_lstop (struct ps_prochandle *ph, lwpid_t lwpid)
765 ps_lcontinue (struct ps_prochandle *ph, lwpid_t lwpid)
770 /* Looks up the symbol LD_SYMBOL_NAME in the debugger's symbol table. */
773 ps_pglobal_lookup (struct ps_prochandle *ph, const char *ld_object_name,
774 const char *ld_symbol_name, psaddr_t *ld_symbol_addr)
776 struct bound_minimal_symbol ms;
778 ms = lookup_minimal_symbol (ld_symbol_name, NULL, NULL);
782 *ld_symbol_addr = BMSYMBOL_VALUE_ADDRESS (ms);
786 /* Common routine for reading and writing memory. */
789 rw_common (int dowrite, const struct ps_prochandle *ph, psaddr_t addr,
790 gdb_byte *buf, int size)
794 scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
796 if (ptid_tid_p (inferior_ptid) || !target_thread_alive (inferior_ptid))
798 /* It's either a thread or an LWP that isn't alive. Any live
799 LWP will do so use the first available.
801 NOTE: We don't need to call switch_to_thread; we're just
803 inferior_ptid = procfs_first_available ();
806 #if defined (__sparcv9)
807 /* For Sparc64 cross Sparc32, make sure the address has not been
808 accidentally sign-extended (or whatever) to beyond 32 bits. */
809 if (bfd_get_arch_size (exec_bfd) == 32)
814 ret = target_write_memory (addr, (gdb_byte *) buf, size);
816 ret = target_read_memory (addr, (gdb_byte *) buf, size);
818 return (ret == 0 ? PS_OK : PS_ERR);
821 /* Copies SIZE bytes from target process .data segment to debugger memory. */
824 ps_pdread (struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t size)
826 return rw_common (0, ph, addr, (gdb_byte *) buf, size);
829 /* Copies SIZE bytes from debugger memory .data segment to target process. */
832 ps_pdwrite (struct ps_prochandle *ph, psaddr_t addr,
833 const void *buf, size_t size)
835 return rw_common (1, ph, addr, (gdb_byte *) buf, size);
838 /* Copies SIZE bytes from target process .text segment to debugger memory. */
841 ps_ptread (struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t size)
843 return rw_common (0, ph, addr, (gdb_byte *) buf, size);
846 /* Copies SIZE bytes from debugger memory .text segment to target process. */
849 ps_ptwrite (struct ps_prochandle *ph, psaddr_t addr,
850 const void *buf, size_t size)
852 return rw_common (1, ph, addr, (gdb_byte *) buf, size);
855 /* Get general-purpose registers for LWP. */
858 ps_lgetregs (struct ps_prochandle *ph, lwpid_t lwpid, prgregset_t gregset)
860 ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
861 struct regcache *regcache
862 = get_thread_arch_regcache (ptid, target_gdbarch ());
864 target_fetch_registers (regcache, -1);
865 fill_gregset (regcache, (gdb_gregset_t *) gregset, -1);
870 /* Set general-purpose registers for LWP. */
873 ps_lsetregs (struct ps_prochandle *ph, lwpid_t lwpid,
874 const prgregset_t gregset)
876 ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
877 struct regcache *regcache
878 = get_thread_arch_regcache (ptid, target_gdbarch ());
880 supply_gregset (regcache, (const gdb_gregset_t *) gregset);
881 target_store_registers (regcache, -1);
886 /* Log a message (sends to gdb_stderr). */
889 ps_plog (const char *fmt, ...)
893 va_start (args, fmt);
895 vfprintf_filtered (gdb_stderr, fmt, args);
898 /* Get size of extra register set. Currently a noop. */
901 ps_lgetxregsize (struct ps_prochandle *ph, lwpid_t lwpid, int *xregsize)
906 /* Get extra register set. Currently a noop. */
909 ps_lgetxregs (struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
914 /* Set extra register set. Currently a noop. */
917 ps_lsetxregs (struct ps_prochandle *ph, lwpid_t lwpid, caddr_t xregset)
922 /* Get floating-point registers for LWP. */
925 ps_lgetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
926 prfpregset_t *fpregset)
928 ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
929 struct regcache *regcache
930 = get_thread_arch_regcache (ptid, target_gdbarch ());
932 target_fetch_registers (regcache, -1);
933 fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1);
938 /* Set floating-point regs for LWP. */
941 ps_lsetfpregs (struct ps_prochandle *ph, lwpid_t lwpid,
942 const prfpregset_t * fpregset)
944 ptid_t ptid = ptid_build (ptid_get_pid (inferior_ptid), lwpid, 0);
945 struct regcache *regcache
946 = get_thread_arch_regcache (ptid, target_gdbarch ());
948 supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset);
949 target_store_registers (regcache, -1);
955 /* Identify process as 32-bit or 64-bit. At the moment we're using
956 BFD to do this. There might be a more Solaris-specific
957 (e.g. procfs) method, but this ought to work. */
960 ps_pdmodel (struct ps_prochandle *ph, int *data_model)
963 *data_model = PR_MODEL_UNKNOWN;
964 else if (bfd_get_arch_size (exec_bfd) == 32)
965 *data_model = PR_MODEL_ILP32;
967 *data_model = PR_MODEL_LP64;
971 #endif /* PR_MODEL_LP64 */
973 #if (defined(__i386__) || defined(__x86_64__)) && defined (sun)
975 /* Reads the local descriptor table of a LWP.
977 This function is necessary on x86-solaris only. Without it, the loading
978 of libthread_db would fail because of ps_lgetLDT being undefined. */
981 ps_lgetLDT (struct ps_prochandle *ph, lwpid_t lwpid,
984 /* NOTE: only used on Solaris, therefore OK to refer to procfs.c. */
987 /* FIXME: can't I get the process ID from the prochandle or
990 if (ptid_get_pid (inferior_ptid) <= 0 || lwpid <= 0)
993 ret = procfs_find_LDT_entry (ptid_build (ptid_get_pid (inferior_ptid),
997 memcpy (pldt, ret, sizeof (struct ssd));
1001 /* LDT not found. */
1007 /* Convert PTID to printable form. */
1010 sol_thread_target::pid_to_str (ptid_t ptid)
1012 static char buf[100];
1014 if (ptid_tid_p (ptid))
1018 lwp = thread_to_lwp (ptid, -2);
1020 if (ptid_get_pid (lwp) == -1)
1021 xsnprintf (buf, sizeof (buf), "Thread %ld (defunct)",
1022 ptid_get_tid (ptid));
1023 else if (ptid_get_pid (lwp) != -2)
1024 xsnprintf (buf, sizeof (buf), "Thread %ld (LWP %ld)",
1025 ptid_get_tid (ptid), ptid_get_lwp (lwp));
1027 xsnprintf (buf, sizeof (buf), "Thread %ld ",
1028 ptid_get_tid (ptid));
1030 else if (ptid_get_lwp (ptid) != 0)
1031 xsnprintf (buf, sizeof (buf), "LWP %ld ", ptid_get_lwp (ptid));
1033 xsnprintf (buf, sizeof (buf), "process %d ", ptid_get_pid (ptid));
1039 /* Worker bee for update_thread_list. Callback function that gets
1040 called once per user-level thread (i.e. not for LWP's). */
1043 sol_update_thread_list_callback (const td_thrhandle_t *th, void *ignored)
1049 retval = p_td_thr_get_info (th, &ti);
1050 if (retval != TD_OK)
1053 ptid = ptid_build (ptid_get_pid (inferior_ptid), 0, ti.ti_tid);
1054 if (!in_thread_list (ptid) || is_exited (ptid))
1061 sol_thread_target::update_thread_list ()
1063 struct target_ops *beneath = find_target_beneath (this);
1065 /* Delete dead threads. */
1068 /* Find any new LWP's. */
1069 beneath->update_thread_list ();
1071 /* Then find any new user-level threads. */
1072 p_td_ta_thr_iter (main_ta, sol_update_thread_list_callback, (void *) 0,
1073 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1074 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1077 /* Worker bee for the "info sol-thread" command. This is a callback
1078 function that gets called once for each Solaris user-level thread
1079 (i.e. not for LWPs) in the inferior. Print anything interesting
1080 that we can think of. */
1083 info_cb (const td_thrhandle_t *th, void *s)
1088 ret = p_td_thr_get_info (th, &ti);
1091 printf_filtered ("%s thread #%d, lwp %d, ",
1092 ti.ti_type == TD_THR_SYSTEM ? "system" : "user ",
1093 ti.ti_tid, ti.ti_lid);
1094 switch (ti.ti_state)
1097 case TD_THR_UNKNOWN:
1098 printf_filtered ("<unknown state>");
1100 case TD_THR_STOPPED:
1101 printf_filtered ("(stopped)");
1104 printf_filtered ("(run) ");
1107 printf_filtered ("(active) ");
1110 printf_filtered ("(zombie) ");
1113 printf_filtered ("(asleep) ");
1115 case TD_THR_STOPPED_ASLEEP:
1116 printf_filtered ("(stopped asleep)");
1119 /* Print thr_create start function. */
1120 if (ti.ti_startfunc != 0)
1122 const struct bound_minimal_symbol msym
1123 = lookup_minimal_symbol_by_pc (ti.ti_startfunc);
1125 printf_filtered (" startfunc=%s",
1127 ? MSYMBOL_PRINT_NAME (msym.minsym)
1128 : paddress (target_gdbarch (), ti.ti_startfunc));
1131 /* If thread is asleep, print function that went to sleep. */
1132 if (ti.ti_state == TD_THR_SLEEP)
1134 const struct bound_minimal_symbol msym
1135 = lookup_minimal_symbol_by_pc (ti.ti_pc);
1137 printf_filtered (" sleepfunc=%s",
1139 ? MSYMBOL_PRINT_NAME (msym.minsym)
1140 : paddress (target_gdbarch (), ti.ti_pc));
1143 printf_filtered ("\n");
1146 warning (_("info sol-thread: failed to get info for thread."));
1151 /* List some state about each Solaris user-level thread in the
1155 info_solthreads (const char *args, int from_tty)
1157 p_td_ta_thr_iter (main_ta, info_cb, (void *) args,
1158 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1159 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1162 /* Callback routine used to find a thread based on the TID part of
1166 thread_db_find_thread_from_tid (struct thread_info *thread, void *data)
1168 long *tid = (long *) data;
1170 if (ptid_get_tid (thread->ptid) == *tid)
1177 sol_thread_target::get_ada_task_ptid (long lwp, long thread)
1179 struct thread_info *thread_info =
1180 iterate_over_threads (thread_db_find_thread_from_tid, &thread);
1182 if (thread_info == NULL)
1184 /* The list of threads is probably not up to date. Find any
1185 thread that is missing from the list, and try again. */
1186 update_thread_list ();
1187 thread_info = iterate_over_threads (thread_db_find_thread_from_tid,
1191 gdb_assert (thread_info != NULL);
1193 return (thread_info->ptid);
1197 _initialize_sol_thread (void)
1201 dlhandle = dlopen ("libthread_db.so.1", RTLD_NOW);
1205 #define resolve(X) \
1206 if (!(p_##X = (X ## _ftype *) dlsym (dlhandle, #X))) \
1210 resolve (td_ta_new);
1211 resolve (td_ta_delete);
1213 resolve (td_ta_get_ph);
1214 resolve (td_ta_get_nthreads);
1215 resolve (td_ta_tsd_iter);
1216 resolve (td_ta_thr_iter);
1217 resolve (td_thr_validate);
1218 resolve (td_thr_tsd);
1219 resolve (td_thr_get_info);
1220 resolve (td_thr_getfpregs);
1221 resolve (td_thr_getxregsize);
1222 resolve (td_thr_getxregs);
1223 resolve (td_thr_sigsetmask);
1224 resolve (td_thr_setprio);
1225 resolve (td_thr_setsigpending);
1226 resolve (td_thr_setfpregs);
1227 resolve (td_thr_setxregs);
1228 resolve (td_ta_map_id2thr);
1229 resolve (td_ta_map_lwp2thr);
1230 resolve (td_thr_getgregs);
1231 resolve (td_thr_setgregs);
1233 add_cmd ("sol-threads", class_maintenance, info_solthreads,
1234 _("Show info on Solaris user threads."), &maintenanceinfolist);
1236 /* Hook into new_objfile notification. */
1237 gdb::observers::new_objfile.attach (sol_thread_new_objfile);
1241 fprintf_unfiltered (gdb_stderr, "\
1242 [GDB will not be able to debug user-mode threads: %s]\n", dlerror ());